gRPC limits

Per-plan gRPC limits: concurrent connections, per-stream filter caps (accounts, owners, transactions, blocks), and unlimited/unmetered throughput. No per-MB billing.

// updated 2026-07-30

Every gRPC stream must include a filter - there is no unfiltered firehose. These caps define how broad a single stream's filter can be on your plan.

How are gRPC limits structured?

gRPC is limited on 5 independent axes, plus one control-plane limit:

Connections (per plan) - how many live Subscribe streams you can open at once: FOCUS 1 / BUILD 10 / GROW 20 / PRO 50 / Dedicated unlimited.
Subscriptions (per plan) - how many subscriptions you can hold across those connections: FOCUS 6 / BUILD 40 / GROW 80 / PRO 200 / Dedicated unlimited. This is a separate quota from connections.
Filters per connection - how many named rules live in one SubscribeRequest. Categories combine with AND; values inside one array (and multiple named filters in a category) combine with OR. You can rewrite a subscription on the fly - a new SubscribeRequest fully replaces the old one.
Filter width (per stream) - how many addresses a single stream can match: array sizes like account_max, owner_max, account_include_max. owner is the heaviest - it fans out to every account a program owns - so it has the tightest cap.
Throughput - the volume of data Supanode pushes to you. On Supanode this is unlimited and unmetered (no per-MB or per-credit billing). The only volume gate is unfiltered block streaming, which is included in the PROFESSIONAL tier.

Control plane: you can re-send a SubscribeRequest to swap filters up to 30 times per minute - the same on every tier. See filter update rate.

NOTE

Caps are per stream, connections are the plan quota. Every cap in the per-category table below applies to a single SubscribeRequest (one stream). The connection count is how many such streams you can run in parallel. So your total reach is roughly account_max × connections - see the Total reach callout.

How many gRPC connections can I run at once?

How many live gRPC streams you can run at the same time, per plan.

Plan	Concurrent connections
STARTER	not included
FOCUS	1
BUILD	10
GROW	20
PROFESSIONAL	50
Dedicated	unlimited

The STARTER plan ($40/mo) does not include gRPC. To use gRPC, choose FOCUS, BUILD, GROW, or PROFESSIONAL.

How many subscriptions can I hold?

Subscriptions are a separate quota from connections - one connection can carry several subscriptions.

Plan	Subscriptions
STARTER	not included
FOCUS	6
BUILD	40
GROW	80
PROFESSIONAL	200
Dedicated	unlimited

What are the per-stream filter caps?

Each value below is the maximum size of that field within a single SubscribeRequest. For the parameterless stream types (slots, blocks_meta, entry) the number is the maximum count of named filters of that type in one stream.

Field (per stream)	FOCUS	BUILD	GROW	PROFESSIONAL	Dedicated
`accounts.account_max`	100	500	1,200	2,000	unlimited
`accounts.owner_max`	not available	5	20	50	unlimited
`accounts.data_slice_max`	10	10	10	10	unlimited
`slots.max`	10	25	50	100	unlimited
`blocks.account_include_max`	25	100	200	500	unlimited
`blocks`: include transactions / accounts / entries	all allowed	all	all	all	all
`blocks_meta.max`	10	10	10	10	unlimited
`transactions.account_include_max`	100	500	1,200	2,000	unlimited
`transactions.account_exclude_max`	100	500	1,200	2,000	unlimited
`transactions.account_required_max`	100	500	1,200	2,000	unlimited
`transactions_status.account_include_max`	25	100	200	500	unlimited
`transactions_status.account_exclude_max`	25	100	200	500	unlimited
`transactions_status.account_required_max`	25	100	200	500	unlimited
`entry.max`	10	10	10	10	unlimited

accounts.owner_max is the number of owner programs one stream may filter on. It is intentionally tight - an owner filter expands to every account a program owns, the single heaviest filter you can write - and it is not available on FOCUS at all. There is no separate "filters per type" cap on top of this: the array sizes above already bound how broad one stream can be.

How many accounts can I watch across all streams?

TIP

Across all your streams you can watch up to account_max × connections accounts. For GROW that is 1,200 × 20 = up to 24,000 accounts. This is a ceiling - you spread accounts across separate streams, since the array cap applies per stream. Headline reach per plan:

Plan	Max accounts watched
FOCUS	up to 100
BUILD	up to 5,000
GROW	up to 24,000
PROFESSIONAL	up to 100,000
Dedicated	unlimited

Is gRPC throughput metered?

NOTE

Throughput is unlimited and unmetered on every gRPC tier. Supanode bills by plan tier, so the data your streams deliver carries no per-MB, per-GB, or per-credit charge. The only volume gate is unfiltered block streaming (empty-filter "firehose" mode), which is included in the PROFESSIONAL tier.

Filter update rate

Maximum rate at which you can re-send a SubscribeRequest to swap your filters.

Plan	Filter updates
STARTER	not included
FOCUS	30 / min
BUILD	30 / min
GROW	30 / min
PROFESSIONAL	30 / min
Dedicated	unlimited

Per-tier filter caps (copy-paste)

A quick reference for the per-stream caps on each tier.

{
  "connections": 1,
  "subscriptions": 6,
  "filter_updates_per_min": 30,
  "accounts": { "account_max": 100, "owner_max": null, "data_slice_max": 10 },
  "slots": { "max": 10 },
  "blocks": { "account_include_max": 25 },
  "blocks_meta": { "max": 10 },
  "transactions": { "account_include_max": 100, "account_exclude_max": 100, "account_required_max": 100 },
  "transactions_status": { "account_include_max": 25, "account_exclude_max": 25, "account_required_max": 25 },
  "entry": { "max": 10 },
  "throughput": "unlimited",
  "max_accounts_watched": 100
}

What happens when you hit a limit

Filter too broad - if a stream's filter exceeds the per-category caps above, the server returns ResourceExhausted (gRPC status code 8).
Malformed filter - a structurally invalid SubscribeRequest is rejected with INVALID_ARGUMENT.
Connection cap exceeded - a new stream beyond your plan's connection quota is refused, or the connection is closed. Existing streams keep working.

There are no per-event or per-MB throughput caps on gRPC streams. Your constraints are connections, subscriptions, filter width, and the per-tier filter update rate.