Bedrock "Too Many Requests, Please Wait Before Trying Again" (ThrottlingException): Every Fix

Logeshwaran
—

"Too many requests, please wait before trying again" is Amazon Bedrock's ThrottlingException, HTTP 429: your request went over one of your account's quotas for that model, in that Region. Waiting and retrying with backoff fixes a short burst. It does not fix the two causes behind most of the long-running cases, and they are not what people expect. First, on a new or lightly used AWS account, a model's quota can be set to zero, so the very first request is throttled even though you have sent nothing. Second, Bedrock reserves your input tokens plus your entire max_tokens against the per-minute quota the moment each request starts, and counts every output token up to 15 times for some Claude models, so a quota that looks generous runs out after a handful of calls. Both show up in Service Quotas and CloudWatch within two minutes, once you know where to look.

Jake's nephew is studying software, and over a weekend he built a small tool for Jake's phone repair shop: paste in a customer's description of the damage, and it drafts a repair quote with the likely parts. He built it on a brand-new AWS account, tried it once in the Bedrock playground, and got "Too many requests, please wait before trying again." He waited an hour. Same message. He waited until morning. Same message, from the playground and from his code. He was sure AWS was down. Ethan, who looks after AWS for a few local businesses, opened Service Quotas on the nephew's laptop and found the answer in under a minute: the account's quota for that model was 0. This page covers that case and every other reason Bedrock throttles: how to read your quotas, the token math that empties them, the daily cap behind "Too many tokens per day", how retries should work, what is different on Bedrock Mantle, and how to get more capacity when you genuinely need it.

⚡ Quick Answer

• What it is → ThrottlingException (429): an account quota for that model was exceeded. Not an outage; 503 and 529 are the capacity errors. The meaning.

• Throttled on the first call? → Your quota is probably 0. Check Service Quotas; request an increase or open a Support case. The zero-quota case.

• Throttled under light use? → Lower max_tokens. Bedrock reserves input + max_tokens up front, and output counts 5x to 15x for Claude. The token math.

• "Too many tokens per day" → The account-wide Cross-Model Max Tokens Per Day quota. It is raised together with the per-minute one. The daily cap.

• Retries → Exponential backoff with jitter; in boto3, retries={"mode": "adaptive"}. Never retry in a tight loop. Retry code.

Cached prompt tokens do not count against the per-minute quota, so prompt caching is the cheapest way to get more throughput out of the same limit.

If you found the long forum thread with this title while searching, you will have seen dozens of people with the same symptom and a mix of answers. Most of those answers are right for someone. The trick is working out which cause is yours, and that takes two screens: Service Quotas for the numbers, and CloudWatch for what your requests actually consumed.

🧭 NEW HERE? READ THESE FIRST

If Bedrock, CloudWatch or "tokens" are new to you, these five pages make the rest of this one easier:

📌 Bookmark this; the quota math below assumes you know what a token is.

What "Too many requests, please wait before trying again" means

Amazon Bedrock returns three different "busy" errors, and they mean different things:

ErrorHTTPMeaningYour move
ThrottlingException ("Too many requests", "Too many tokens per day")429You exceeded one of your account's quotasFind which quota; slow down, use less, or raise it
ServiceUnavailable503High demand or temporary capacity limits, not your quotaRetry with backoff; try cross-Region inference
overloaded_error529The model is temporarily over capacityRetry with backoff and jitter; honor Retry-After

"Too many requests, please wait before trying again" is the first row. AWS's own definition of ThrottlingException is that the request was denied for exceeding the account quotas for Amazon Bedrock. So the question is never "is Bedrock down?" but "which of my quotas did this request hit?" The same wording appears in the Bedrock playground, because the console uses the same quotas as your code, which is why throttling in both places at once points straight at a quota.

On Knowledge Bases the same condition can surface differently, for example as ThrottlingException from RetrieveAndGenerate with "Your request rate is too high. Reduce the frequency of requests", after the SDK has used up its retries.

The six causes of Bedrock throttling, in the order to check them

  1. The quota is zero or tiny. Common on new or low-usage accounts. Every request is throttled, including the first.
  2. The per-minute token quota is used up by reservations. Each request reserves input plus max_tokens at the start. A large max_tokens blocks other requests even if the replies are short.
  3. Output tokens count several times over. Many models count each output token 5, 10 or 15 times against the quota, while billing it once.
  4. A requests-per-minute quota. Some models have one, and many small requests can hit it while tokens are fine.
  5. The daily cap. "Too many tokens per day" is the account-wide Cross-Model Max Tokens Per Day quota.
  6. Bursts and retry storms. Many requests arriving in the same second, or clients retrying immediately and together, throttle themselves even with headroom on paper.

The first cause explains the "I've only invoked it three times this week" reports. The second and third explain "I'm well under the limit and still throttled". The fifth explains the "per day" variant. The sixth is the one load tests discover.

How to check your Bedrock quotas in two minutes

Open the Service Quotas console in the same Region your code calls, choose Amazon Bedrock, and search for the model's name. Look at the Applied account-level quota value column, not only the AWS default; the applied value is what your account actually has. Or from the CLI:

aws service-quotas list-service-quotas \
  --service-code bedrock \
  --region us-east-1 \
  --query "Quotas[?contains(QuotaName, 'Sonnet')].[QuotaName,Value,Adjustable]" \
  --output table

On the bedrock-runtime endpoint, these are the quotas that throttle model calls:

Quota nameScopeApplies when
Cross-Region tokens per minute for model (also shown as "Cross-region model inference tokens per minute")Per model, per RegionYou call a geographic profile (us., eu., apac. ...)
Global cross-Region model inference tokens per minute for modelPer model, one global limitYou call a global. profile
On-demand InvokeModel tokens per minute for modelPer model, per RegionYou call the plain model ID in one Region
InvokeModel requests per minute for modelPer model, per RegionOnly for models that have an RPM quota
Cross-Model Max Tokens Per DayPer account, per RegionAlways: all supported models together

AWS pages spell some of these names slightly differently, so in Service Quotas search for the model name rather than the exact quota title. Requests-per-minute quotas follow the same pattern, with geographic and global versions. Three details matter. The "InvokeModel" in the names is historical: the quotas cover every API you call the model with on that endpoint, including Converse, Responses and Chat Completions. The token quotas count input and output together. And the right quota depends on how you call the model: if your code uses us.anthropic..., it is the geographic Cross-Region quota that matters, if it uses global. it is the Global one, and raising the On-demand quota changes neither. If a plain model ID returns a different error about on-demand throughput instead, our guide to the "on-demand throughput isn't supported" error covers that switch.

Not every model has an RPM quota. Some, such as Claude Opus 4.7 and Claude Opus 4.8, are governed only by the token quotas.

On-demand, geographic and global: three separate quota buckets

One of the least obvious facts about Bedrock throttling is that the same model has up to three independent token allowances on bedrock-runtime, depending on how you call it:

  • On-demand, for the plain model ID in one Region. Per model, per Region.
  • Geographic cross-Region, for profiles such as us. or eu.. Per model, per Region, viewed and raised in the Region you call from.
  • Global cross-Region, for global. profiles. This one is a global limit: you can call a global profile from more than 20 source Regions, and they draw on one allowance. You still view and request increases in Service Quotas from your source Region, where it appears as, for example, "Global cross-Region model inference tokens per minute for" followed by the model name.

That has practical consequences. Switching an app from us. to global. moves it to a different quota with a different value, so a throttling problem can appear or disappear with that one change. An increase approved for one bucket does nothing for the others. And because the global allowance is shared, deploying the same app in more Regions does not multiply your global quota the way it would for per-Region buckets.

Bedrock Mantle adds a fourth, entirely separate set of quotas for the same model, covered further down. When you open a quota request, name the bucket you actually use; it saves a round trip with Support.

Throttled on the very first request: the zero-quota account

This is the case that fills that forum thread, and the one Jake's nephew hit. The symptoms are unmistakable: "Too many requests" from the first call, in the playground and in code, for hours, with CloudWatch showing almost no usage. Several people in that thread found the cause the same way: Service Quotas showed an applied value of 0 for the models they were calling, while a model they had never used showed a normal number.

AWS is open about why this can happen. The default quotas assigned to an account can be adjusted based on Regional factors, payment history, fraudulent usage and approval of increase requests. A brand-new account, or one that has barely spent anything, can start with very low or zero quotas for some models.

The fix, in order:

  1. Confirm it. In Service Quotas, check the applied value for the model's Cross-Region tokens-per-minute quota (or On-demand, if you call the plain ID) in your Region.
  2. Try another Region you are allowed to use in the same account. Quotas are per Region, and the original poster in the thread found one Region working while the US ones were throttled.
  3. Request an increase on the model's Cross-Region InvokeModel tokens per minute quota. AWS uses that one request to cover the per-minute quotas and the daily cap together.
  4. If the request is denied or the quota is not adjustable, open an AWS Support case. People in the thread reported success with a case under Account and Billing on the free Basic Support plan, resolved in about 48 hours. Explain that the quota is 0, name the model and Region, and describe what you are building.

Be realistic about step 3. Because of demand, increases go first to customers who are already using their existing allocation. An account with zero usage has nothing to show yet, which is why the Support case is often the faster path.

Ethan opened the case for the nephew on a Saturday morning, describing the shop's quote tool in two sentences. It was sorted on Monday. In the meantime they tested with a model whose quota was not zero, so the weekend was not wasted.

The token math: why you are throttled "well under the limit"

The per-minute token quotas do not count tokens the way your bill does. Here is exactly how a request is charged against your quota:

  • When the request starts, Bedrock deducts total input tokens + max_tokens. If that does not fit in what is left of the minute's quota, the request is throttled immediately.
  • While it runs, the deduction is adjusted for the output actually generated.
  • When it finishes, the final cost is InputTokenCount + CacheWriteInputTokenCount + (OutputTokenCount x burndown rate), and anything unused is returned. Cached tokens that were read do not count at all.

The burndown rate is the multiplier on output tokens, and it varies by model:

Model (bedrock-runtime)Each output token uses
Claude models version 4.815 tokens of quota
Claude Opus 5.5, Claude Sonnet 5, Claude Opus 5, Claude Fable 5.110 tokens
Other Claude models, version 4.7 and earlier5 tokens
OpenAI GPT-5.6 Sol, Terra and Luna; GPT-6.1 Sol10 tokens
All other models1 token

You are billed for one token per output token in every case; the multiplier applies only to the quota. Check the model's own page for models not listed here.

Here is what that does to a typical request on a model with a burndown of 10. The request has 3,000 input tokens, max_tokens set to 32,000, and the model actually writes 800 tokens:

  • Reserved at the start: 3,000 + 32,000 = 35,000 tokens of quota.
  • Final cost: 3,000 + (800 × 10) = 11,000 tokens of quota.
  • Billed: 3,800 tokens.

Now suppose, purely as an example, that your quota for the model were 100,000 tokens per minute. With max_tokens at 32,000, only two of those requests can be in flight at once, because each reserves 35,000; the third is throttled even though the first two will end up using 11,000 each. Lower max_tokens to 2,000 and each request reserves 5,000, so many more fit inside the same minute. Nothing about the replies changes; you just stopped reserving space you never used.

An example makes the same point with a model that has a burndown of 5: 3,000 input tokens, 1,000 written to the cache, 1,000 output and max_tokens of 32,000 reserves 36,000 at the start for a final cost of 9,000. With max_tokens of 1,250, the start reservation drops to 5,250 for the same final cost.

The quote tool, once its quota was fixed, was set to max_tokens 4,096 by default from a copied example. Its quotes were about 400 tokens. Ethan changed it to 800, and the tool could suddenly serve the whole shop's afternoon rush without a single throttle.

How many requests fit in your quota: a planning formula

Once you know the quota and the token math, you can estimate your ceiling before a launch instead of discovering it during one. Two numbers matter for a model with burndown rate B:

  • Admission cost per request = input tokens + max_tokens. This decides how many requests can start inside one minute.
  • Final cost per request = input tokens + cache writes + (output tokens × B). This decides your sustained rate once requests finish and return their unused reservation.

A rough planning rule follows. Requests that can start in the same minute: about quota ÷ admission cost. Requests you can sustain per minute: about quota ÷ final cost. The real number sits between the two, depending on how long each request runs, because a request's reservation is only returned when it finishes.

Worked through for a support assistant on a model with B = 10, 2,500 input tokens per request, replies averaging 300 tokens, and, as an example only, a quota of 200,000 tokens per minute:

max_tokensAdmission costCan start per minuteFinal costSustained per minute
32,00034,500about 55,500about 36
4,0966,596about 305,500about 36
6003,100about 645,500about 36

Two lessons sit in that table. First, a huge max_tokens mostly hurts bursts: with 32,000, only about five requests can start at once, so a busy moment throttles even though the sustained rate is the same. Second, the sustained ceiling is set by the final cost, and the output multiplier dominates it: 300 output tokens count as 3,000. Shorter replies and prompt caching raise the sustained ceiling; a smaller max_tokens raises the burst ceiling. If both are too low for your traffic, that is the moment for a quota increase, with these numbers in the request.

How to choose max_tokens from your real usage

Set max_tokens a little above what your longest normal reply needs, not at the model's maximum. CloudWatch shows you the number:

  1. Open the CloudWatch console and choose Dashboards.
  2. Choose the Automatic dashboards tab, then Bedrock.
  3. Expand the Token Counts by Model widget.
  4. Pick a time range that includes your busiest period.
  5. Use the dropdown labeled Sum to choose the token metrics, and note your largest normal output per request.

Two newer metrics make this easier. EstimatedTPMQuotaUsage estimates your tokens-per-minute quota consumption across Converse and InvokeModel calls, which is the number to compare against your quota value. And InvocationThrottles counts throttled requests, which are not included in Invocations or the error counts, so a throttling problem can hide from a dashboard that only watches errors. An alarm on InvocationThrottles is the simplest early warning there is; our CloudWatch guide shows how to create one.

Two details in AWS's metric definitions save a lot of confusion when you read these graphs. First, the throttle count you see depends on your SDK's retry settings: every retry that is throttled again counts again, so an aggressive retry policy can make one burst look like a flood. Second, requests rejected for exceeding a service quota are counted in InvocationClientErrors, not as throttles. If InvocationThrottles looks calm but users still see errors, check the client errors graph too.

For reasoning models, remember that thinking counts as output. A model that thinks before answering needs more max_tokens than its visible reply suggests, so measure the output token count, not the length of the text you see.

"Too many tokens per day": the daily cap

The variant "ThrottlingException: Too many tokens per day, please wait before trying again" comes from a different quota: Cross-Model Max Tokens Per Day. It is per account and per Region, and it counts all supported Bedrock models together. AWS estimates the count from on-demand pricing, so the actual number of tokens it allows varies with the model, the input-to-output mix and how much you use the cache.

Because it is a daily total, waiting a few seconds does not help, and retry loops only add noise. The options are to spread heavy jobs across days, move non-urgent volume to batch inference, which has its own separate quotas, cut usage with caching and smaller outputs, or raise the cap. The daily cap is raised in the same request as the per-minute quotas: request an increase on the model's Cross-Region tokens-per-minute quota and AWS treats it as covering the combination.

A new account hitting "Too many tokens per day" after a few test calls is usually the zero-or-tiny quota case again, just reported by a different counter.

How to retry Bedrock throttling properly

Retries are the right response to short bursts, and the wrong response to a quota of zero. Use exponential backoff with random jitter, so that clients do not all retry at the same moment. The AWS SDKs do this for you if you let them. In boto3:

import boto3
from botocore.config import Config

brt = boto3.client(
    "bedrock-runtime",
    region_name="us-east-1",
    config=Config(retries={"max_attempts": 8, "mode": "adaptive"}),
)

The adaptive mode adds client-side rate limiting on top of standard backoff, which helps when many threads share one client. standard is the safe default if you prefer plain backoff. If you write your own retry loop, keep it simple and bounded:

import random, time
from botocore.exceptions import ClientError

def call_with_backoff(fn, attempts=6, base=1.0, cap=30.0):
    for n in range(attempts):
        try:
            return fn()
        except ClientError as e:
            code = e.response["Error"]["Code"]
            if code not in ("ThrottlingException", "ServiceUnavailableException") or n == attempts - 1:
                raise
            time.sleep(random.uniform(0, min(cap, base * 2 ** n)))   # full jitter

Three rules keep retries from making things worse. Cap the number of attempts, so a real quota problem surfaces as an error instead of a hang. Do not retry ValidationException or AccessDeniedException; they will never succeed. And if many workers share a quota, add a queue or a concurrency limit in front of Bedrock, so you are not relying on throttling to pace them.

Throttling in LangChain and other frameworks

Frameworks sit on top of the AWS SDK, so the same quotas and the same retry rules apply; you just set them in a different place.

LangChain: ChatBedrockConverse accepts max_retries, which it passes to botocore as the retry attempt count, or a full botocore Config through its config parameter. It also accepts max_tokens, which is the setting that matters most for throttling:

from botocore.config import Config
from langchain_aws import ChatBedrockConverse

llm = ChatBedrockConverse(
    model="us.anthropic.claude-sonnet-5-5",
    region_name="us-east-1",
    max_tokens=800,
    config=Config(retries={"max_attempts": 8, "mode": "adaptive"}),
)

Knowledge Bases: RetrieveAndGenerate uses the quotas of the model you chose for answers. If it reports "Your request rate is too high", pace concurrent queries and check that model's quota and output settings, as above.

Agents and multi-step tools: one user action can turn into several model calls. Count calls per action when you plan, not user actions, or your quota math will be off by a factor of three or four.

Load tests: start low and step up, and watch InvocationThrottles as you go. A load test that fires its whole volume in the first second measures the burst ceiling, which is rarely what real users do.

Get more out of the quota you have

  • Right-size max_tokens. The biggest single win, as shown above.
  • Use prompt caching. Tokens read from the cache do not count against the per-minute quota at all, and they are cheaper. If every request repeats the same long instructions or documents, caching them gives you throughput and savings at once. Tokens written to the cache do count, once.
  • Move batch work to batch inference. Overnight summaries, back-catalog processing and evaluations belong in batch jobs, which have their own quotas and do not compete with your live traffic.
  • Use the right quota bucket. If you call through an inference profile, make sure you are reading and raising the Cross-Region quota. Calling through a profile also spreads requests across Regions, which helps with 503 and 529 capacity errors.
  • Smooth your traffic. A queue that feeds Bedrock at a steady rate avoids self-inflicted bursts.
  • Pick a smaller model for simple jobs. Classification and extraction rarely need the largest model, and a smaller model can have a lower burndown rate; check its page.

One thing that does not add capacity: the Flex service tier. Flex gives a price discount for work that can wait, but your on-demand quota is shared across the Priority, Standard and Flex tiers, so moving traffic to Flex saves money without creating more quota.

When you need more capacity: increases, Reserved tier, Provisioned Throughput

Quota increases. Request an increase on the model's Cross-Region InvokeModel tokens-per-minute quota in Service Quotas if it is adjustable; that request covers the per-minute quotas and the daily cap together. Include your real usage and a short description of the workload. AWS gives priority to accounts that are using their current allocation, and does not grant increases for models in Legacy or Deprecated status, so plan a migration if you are on an older model.

The Reserved tier reserves prioritized capacity for applications that cannot tolerate throttling, with separate input and output tokens-per-minute allocations. Its minimum is 100,000 input tokens and 10,000 output tokens per minute, it is arranged through your AWS account team, it is billed until the reservation is deleted, and it sits outside your on-demand quota. When sizing it, count both InputTokenCount and cache writes.

Provisioned Throughput buys dedicated model units for steady, predictable volume, with its own quotas, and you call the provisioned model's ARN. Inference profiles do not support it.

The Priority tier gives faster responses at a premium price for customer-facing work, but it draws on the same on-demand quota, so it improves speed rather than adding quota. Not every model supports every tier; each model's page lists the tiers it offers. You choose a tier per request with the service_tier parameter: reserved, priority, default or flex.

How to write a quota increase request that gets approved

Approval depends on whether your existing usage justifies the increase, and that customers already consuming their allocation get priority. So the request should read like evidence, not a wish. Include:

  • The endpoint and Region: bedrock-runtime or bedrock-mantle, and the source Region you call from.
  • The model and the exact bucket: on-demand, geographic cross-Region or global cross-Region, with the quota name as Service Quotas shows it.
  • Current and requested values, and how you arrived at the new number, ideally with the planning formula above.
  • Recent usage: a screenshot or numbers from CloudWatch for EstimatedTPMQuotaUsage, InvocationThrottles, InputTokenCount and OutputTokenCount over the busy period.
  • What you have already optimized: max_tokens sized from real output, prompt caching on, batch work moved to batch inference, retries with backoff.
  • The workload in two sentences: who uses it, and when traffic peaks.

A short example of the kind of text that works:

Endpoint: bedrock-runtime, source Region us-east-1
Model / quota: Claude Sonnet 5.5, geographic cross-Region tokens per minute (us. profile)
Current applied value: [value from Service Quotas]   Requested: [value]
Usage: EstimatedTPMQuotaUsage reached the quota between 16:00 and 18:00 UTC on
weekdays last week; InvocationThrottles averaged [n] per minute in that window.
Already done: max_tokens reduced from 4,096 to 800 based on measured output,
prompt caching enabled for our 6,000-token system prompt, nightly jobs moved to
batch inference, adaptive retries in the SDK.
Workload: customer support assistant for a small retail business; traffic
peaks in the late afternoon.

For a zero-quota account, the same structure works in a Support case; there is simply no usage to show yet, so describe the project and the volume you expect in the first month. Keep the tone factual. The person reading it is checking that the quota will be used as described, and specifics make that easy.

Throttling on Bedrock Mantle works differently

Bedrock has a second endpoint, bedrock-mantle, for the OpenAI and Anthropic APIs, and its quotas are separate from bedrock-runtime's, even for the same model. The differences that change your fix:

  • Separate input and output quotas. Mantle has "Bedrock Mantle input tokens per minute" and "Bedrock Mantle output tokens per minute" per model, instead of one combined quota, and no burndown multiplier.
  • No requests-per-minute quota. Throttling comes only from the two token quotas, plus internal rate limiting that is not shown in Service Quotas.
  • An unset max_tokens reserves the model's maximum. Each request is checked against the input quota using its input tokens plus max_tokens, or the model's own maximum output if you leave max_tokens out. On a model with a 128,000-token output limit, forgetting that one parameter can make every request look enormous to the quota system.
  • Output can be cut short. If the output quota runs out mid-response, generation stops and the response returns with a finish reason, rather than the request being refused at the start.
  • Cached input does not count against the input quota, just as on bedrock-runtime.
  • Increases go through a form, not the console. Mantle quotas are visible in Service Quotas, but increases are requested through the AWS Support limit increase form, naming the endpoint, Region, model, quota and value, with recent usage to justify it.

Our Mantle vs bedrock-runtime guide covers when each endpoint is the right choice.

A ten-minute throttling health check

Before you change code, run through this once with the console open. It tells you which of the six causes you have:

  1. Service Quotas, your Region, Amazon Bedrock: is the applied value for your model's quota 0 or very small?
  2. Which quota? Does your code call a profile (Cross-Region quota) or the plain ID (On-demand quota)? Check the one you actually use.
  3. CloudWatch, Token Counts by Model: what is a typical output per request, and what is your max_tokens?
  4. EstimatedTPMQuotaUsage near the quota at the moments you were throttled? Then it is volume or reservations; if not, look at RPM or the daily cap.
  5. InvocationThrottles clustered in short spikes? Then it is bursts or retry storms; add pacing.
  6. The error text: "per day" means the daily cap, not the per-minute quota.

The throttling checklist for production

  • max_tokens is set from measured output rather than an example value.
  • Prompt caching is on for stable instructions and documents.
  • The SDK uses standard or adaptive retries with a bounded attempt count.
  • A CloudWatch alarm watches InvocationThrottles.
  • Batch jobs run through batch inference, not the live quota.
  • You know which quota bucket you use, and its current value, for every model in production.
  • A quota increase was requested before launch day, with usage numbers attached.
  • Someone knows the Support case route if a quota ever drops to zero.

Frequently asked questions

What does "Too many requests, please wait before trying again" mean in Bedrock?

It is a ThrottlingException, HTTP 429: your request exceeded one of your account's quotas for that model in that Region. It is not an outage; 503 ServiceUnavailable and 529 overloaded_error are the capacity errors.

Why am I throttled on my first Bedrock request?

Your account's quota for that model is probably 0 or very small, which can happen on new or lightly used accounts. Check the applied value in Service Quotas, request an increase, or open an AWS Support case.

What does "Too many tokens per day" mean?

It means you reached the Cross-Model Max Tokens Per Day quota, an account-wide daily cap across all supported Bedrock models in that Region. It is raised together with the per-minute quotas by requesting an increase on the model's Cross-Region tokens-per-minute quota.

Why am I throttled when I'm well under the quota?

Bedrock reserves input tokens plus your full max_tokens at the start of each request, and counts output tokens several times over for many models. A high max_tokens or a 10x or 15x burndown uses up the per-minute quota long before your bill suggests.

What is the Bedrock burndown rate?

The multiplier applied to output tokens for quota purposes. It is 15 for Claude models version 4.8, 10 for Claude Opus 5.5, Sonnet 5, Opus 5, Fable 5.1 and several OpenAI models, 5 for older Claude models, and 1 for most others. Billing is unaffected.

How do I check my Bedrock quotas?

Open Service Quotas in your Region, choose Amazon Bedrock and search for the model, or run aws service-quotas list-service-quotas --service-code bedrock with a query for the model name. Look at the applied account-level value.

How do I request a Bedrock quota increase?

In Service Quotas, request an increase on the model's Cross-Region InvokeModel tokens per minute quota; AWS treats it as covering the per-minute quotas and the daily cap. For bedrock-mantle, use the AWS Support limit increase form instead.

Do cached tokens count against Bedrock quotas?

Tokens read from the prompt cache do not count against the per-minute quota, on both bedrock-runtime and bedrock-mantle. Tokens written to the cache do count, once.

What max_tokens should I set?

A little above your longest normal reply, measured from CloudWatch's Token Counts by Model dashboard. For reasoning models, include thinking tokens, which count as output. Avoid setting it to the model's maximum.

How should I retry Bedrock ThrottlingException?

Use exponential backoff with random jitter and a capped number of attempts. In boto3, Config(retries={"max_attempts": 8, "mode": "adaptive"}) does it for you. Do not retry validation or access errors.

Is ThrottlingException the same as ServiceUnavailableException?

No. ThrottlingException (429) means you exceeded your account's quota. ServiceUnavailable (503) means temporary capacity limits on AWS's side, unrelated to your quota. Both are retried with backoff, but only the first is fixed by quota changes.

Does the Flex tier give me more quota?

No. Flex is cheaper for work that can wait, but your on-demand quota is shared across the Priority, Standard and Flex tiers. The Reserved tier and Provisioned Throughput are the options that sit outside the on-demand quota.

What is the minimum for the Bedrock Reserved tier?

100,000 input tokens per minute and 10,000 output tokens per minute. It is arranged through your AWS account team and billed until the reservation is deleted.

Why do Bedrock Mantle requests throttle without max_tokens?

On bedrock-mantle, a request without max_tokens is checked against the input quota using the model's maximum output size. Setting a realistic max_tokens stops each request from reserving far more quota than it needs.

Does the Bedrock playground use the same quota as my code?

Yes. Throttling in the playground and in code at the same time is a strong sign of a quota problem, such as a zero quota, rather than a bug in your application.

Which CloudWatch metrics show Bedrock throttling?

InvocationThrottles counts throttled requests, which are not included in Invocations or the error metrics. EstimatedTPMQuotaUsage estimates your tokens-per-minute quota consumption, alongside InputTokenCount and OutputTokenCount.

Why does RetrieveAndGenerate say "Your request rate is too high"?

The Knowledge Base call was throttled by a model quota and the SDK exhausted its retries. Check the quotas for the model used to generate answers, lower its max_tokens, and pace concurrent queries.

Are Bedrock quotas per Region?

On-demand and geographic cross-Region quotas are per model and per Region. Global cross-Region quotas are a single global limit for each model, viewed and increased in Service Quotas from your source Region.

Does switching from us. to global. change my quota?

Yes. Geographic and global profiles draw on different quotas with different values, so the same traffic can be throttled on one and not the other. An increase on one does not apply to the other.

Can I set max_tokens in LangChain to avoid throttling?

Yes. ChatBedrockConverse accepts max_tokens, max_retries and a botocore Config, so you can lower the reservation per request and turn on adaptive retries in one place.

Why is Bedrock throttling in one Region but not another?

On-demand and geographic quotas are set per Region, so one Region can have a zero or small quota while another has a normal one. That is exactly what the original forum report showed: US Regions throttled, Sydney working.

How long until Bedrock lets me try again after throttling?

Per-minute quotas free up as the minute rolls over and as running requests finish and return unused reservations, so short bursts clear within seconds with backoff. The daily cap does not clear by waiting minutes, and a zero quota never clears without an increase.

For readers preparing for an AWS certification

We have been covering AWS certifications alongside our fixes, so here is a short extra for readers studying for one. If you only came for the fix, you already have it; feel free to skip this part.

Exams that test this topic: AI Practitioner (AIF-C01) • Developer – Associate (DVA-C03 from December 1, 2026) • Solutions Architect – Associate (SAA-C03).

Here are the exam-style questions this topic tends to raise, with the reasoning you need to answer them:

1. What causes ThrottlingException "Too many requests" on Bedrock?

Exceeding the requests-per-minute or tokens-per-minute quota for that model in the Region.

2. How should the client react?

Retry with exponential backoff and jitter, which the AWS SDKs support.

3. How do you raise available throughput?

Use cross-Region inference profiles and request quota increases through Service Quotas.

4. Why can a large max_tokens value cause throttling?

Token quotas reserve capacity based on requested output tokens, so oversized limits use quota faster.

5. How do you smooth bursts from many users?

Queue requests (for example with SQS) and process them at a controlled rate.

6. Which option guarantees capacity?

Provisioned Throughput.

Exam codes and dates change often. Our AWS certification changes page keeps track of what is current.

Throttling feels personal, as if AWS has decided your project is not important. It is just arithmetic, and usually one number: a quota of zero, a max_tokens copied from an example, or a multiplier nobody mentioned. Jake's nephew got his quota on Monday, trimmed one setting, and the quote tool has drafted every repair estimate since. Jake only asks Ethan one question about it now: whether the bill went up. It did not.

📌 If you keep one line from this page

Bedrock reserves your input plus all of max_tokens before it writes a word, so the cheapest throughput fix is usually a smaller max_tokens.

And if you are throttled on the very first call, check Service Quotas for a zero before you write a single retry.

Revision note. Written October 7, 2026, with Bedrock's quota names and burndown rates current that day. If your weekend project hit a wall on its first request, the wall was a number in a console, and numbers can be changed.

Related