> For the complete documentation index, see [llms.txt](https://docs.triton.one/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.triton.one/using-your-endpoint/rate-and-connection-limits.md).

# Rate and connection limits

Per-IP request and connection limits, how to check yours, and what to do after a 429.

Triton applies limits per IP:

* **Rate limits** cap how many requests an IP can send in a rolling 10-second window. JSON-RPC, gRPC and REST requests all count.
* **Connection limits** cap an IP's connection rate and how many WebSocket connections it can hold open at once.

Behind a proxy, all your users share one IP's limits. See [Proxying](/using-your-endpoint/proxying.md).

Your rate tier sets the values. New subscriptions start on a default tier for their network. On Solana, some RPC methods also have their own caps.

If you need higher limits, contact support. Your rate tier doesn't change your price.

## Rate limits

These budgets apply at the same time, counted over a rolling 10-second window:

* **Total requests.** A budget for your IP across all methods, endpoints and tokens.
* **Per-method limits.** A cap for each method from your IP. Some methods, mostly heavy ones, have their own cap. Every other method uses your tier's default per-method cap.
* **Endpoint requests.** On some tiers, a budget for each token. Requests without a token share one budget per endpoint hostname.

Requests with your token use your token's rate tier. Requests without a token, such as browser calls from an allowed origin, use your endpoint's rate tier. New subscriptions get the same tier for both.

Triton splits some JSON-RPC batches, for example any batch that contains `getProgramAccounts`, `getTransaction` or `sendTransaction`. Each call in a split batch counts as a request, so batching doesn't always save budget.

{% hint style="warning" %}
If any check fails, you get `HTTP 429 Too Many Requests` with `Retry-After: 10`. Pause all requests from that IP for 10 seconds before retrying. Requests you send during the pause still count, so retrying sooner keeps you over the limit.
{% endhint %}

For each 429 message and a backoff example, see [Handle 429 rate-limit errors](/solana/faq/error-handling/handle-429-rate-limit-errors.md).

### Solana per-method limits

Which methods have their own cap, and the values, depend on your rate tier. Where your endpoint returns them, the `X-Ratelimit-Method-Limit` and `X-Ratelimit-Method-Remaining` headers show the cap that applied to each request. For a batch, they show the strictest cap among its methods. Contact support for your tier's full list.

New Solana mainnet shared subscriptions start with these limits per IP:

| Limit                     | Requests per 10 seconds   |
| ------------------------- | ------------------------- |
| Total, across all methods | 2,000                     |
| Default per-method cap    | 2,000                     |
| `sendTransaction`         | 2,000                     |
| `/sendtx`                 | 2,000, on its own counter |

Some heavy methods have lower caps. To see your current total budget, [check your limits](#check-your-limits).

Solana mainnet doesn't serve `getLargestAccounts` or `requestAirdrop`. They return HTTP `410`, or HTTP `429` if your rate tier caps the method at zero. See [Triton RPC error codes](/solana/faq/error-handling/triton-rpc-error-codes.md).

On devnet, `requestAirdrop` also has an hourly cap, counted per /24 block of IP addresses. Going over returns `429` with `Retry-After: 86400`.

## Connection limits

Shared endpoints limit:

| Limit                     | What it caps                                              | Going over                                                                                    |
| ------------------------- | --------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| **Connection rate**       | Counted over the same 10-second window                    | Returns `429` with `Retry-After: 10`                                                          |
| **WebSocket connections** | How many WebSocket connections your IP holds open at once | Returns `429` with no `Retry-After` header. A slot frees when one of your connections closes. |

To stay under the WebSocket limit:

* Close unused connections before you open new ones.
* Put many subscriptions on one connection instead of opening one connection per subscription.
* If you need more, contact support or consider a dedicated node.

Dedicated subscriptions have their own rate tier. Contact support to review it.

## Check your limits

Add `/ratelimits` to your endpoint URL to see your current limits. For example, on Solana mainnet:

```bash
curl "https://<your-endpoint>.mainnet.rpcpool.com/<your-token>/ratelimits"
```

The response is JSON with your request (`rps`), connection (`connections`) and connection-rate (`connrate`) limits, each with how many you have left.

| Field         | What it is                                                                                   |
| ------------- | -------------------------------------------------------------------------------------------- |
| `rps`         | Request limit. Counts requests from your IP in the current 10-second window, not per second. |
| `connections` | Connection limit. For reference only. Going over it doesn't return a `429`.                  |
| `connrate`    | Connection-rate limit                                                                        |
| `airdrop`     | On devnet, the response also includes your `requestAirdrop` limit.                           |

* Values are strings. A limit of `-1` means unlimited.
* `remaining` is the limit minus your current usage.
* With a `-1` limit, `remaining` is always negative. It doesn’t mean you’re over.
* With any other limit, `remaining` below zero means you’re over that limit.
* Per-method caps, the endpoint budget and the WebSocket connection limit aren't included. Where your endpoint returns them, use the `X-Ratelimit-Method-*`, `x-ratelimit-endpoint-*` and `X-Ratelimit-Pubsub-*` headers for those.

Responses can also carry `X-Ratelimit-*` headers. Not every endpoint returns them, and responses served from Triton's cache never do. Where they appear, watch them in your client to slow down **before** you hit a 429:

| Header                                                                                                                 | What it tells you                                                                                                                                |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| `X-Ratelimit-Tier`                                                                                                     | The rate tier applied to your requests                                                                                                           |
| `x-ratelimit-rps-limit` / `x-ratelimit-rps-remaining`, `x-ratelimit-endpoint-limit` / `x-ratelimit-endpoint-remaining` | Request budget for the current 10-second window, per IP (`rps`) and per token or tokenless hostname (`endpoint`), and how many requests are left |
| `X-Ratelimit-Conn-*`, `X-Ratelimit-ConnRate-Limit`, `X-Ratelimit-Pubsub-*`                                             | Concurrent connections (for reference only), connection rate, and WebSocket (pubsub) connections                                                 |
| `X-Ratelimit-Method-Limit`                                                                                             | Per-method cap for this RPC                                                                                                                      |
| `X-Ratelimit-Method-Remaining`                                                                                         | How many of this method you have left                                                                                                            |

## Client-side browser limits

If you connect through a browser, it caps how many requests run in parallel to one host, so a busy frontend can throttle itself before Triton's limits ever apply. To avoid it:

* Reuse one connection per page instead of opening one per call.
* Batch reads with `getMultipleAccounts` instead of many parallel `getAccountInfo` calls.
* Move heavy reads (program scans, signature crawls) to your backend and cache the results. Per-method caps still apply to your backend's IP.

## What's next

<table data-card-size="large" data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><i class="fa-laptop">:laptop:</i> <strong>Customer dashboard tour</strong></td><td>Find your endpoint and token, check usage, and top up your balance.</td><td><a href="/account-and-billing/platform-overview.md">Customer dashboard tour</a></td></tr><tr><td><i class="fa-earth-americas">:earth-americas:</i> <strong>Endpoints, regions, and routing</strong></td><td>Points of presence, endpoint hostnames, protocols, and region pinning.</td><td><a href="/using-your-endpoint/endpoints-regions-routing.md">Endpoints, regions, and routing</a></td></tr></tbody></table>

***

<i class="fa-life-ring">:life-ring:</i> Contact support by clicking the chat icon in your [customer dashboard](https://customers.triton.one)\ <i class="fa-briefcase">:briefcase:</i> Sales questions? [Contact us](https://triton.one/contact)\ <i class="fa-sparkles">:sparkles:</i> AI agent? Read [llms.txt](https://docs.triton.one/llms.txt)\ <i class="fa-rss">:rss:</i> Follow updates: [Blog](https://blog.triton.one) · [X](https://x.com/triton_one) · [YouTube](https://www.youtube.com/@triton_one_ltd) · [Telegram](https://t.me/tritonone) · [GitHub](https://github.com/rpcpool)
