AWS Builder Center
Raise Bedrock Model Quotas Across Every Account in One Command

Raise Bedrock Model Quotas Across Every Account in One Command

An open-source CLI that enables model access and submits Bedrock quota increases across many AWS accounts in a single run — no preconfigured profiles.

Raise Bedrock Model Quotas Across Every Account in One Command

If you run generative AI on Amazon Bedrock across more than a handful of AWS accounts, you already know the chore. A new Claude model ships, your teams want it, and now someone has to log into each account, enable model access, find the right Service Quotas entry, and file an increase — one console tab at a time. Do that for a dozen accounts across a few token dimensions and you've burned an afternoon on clicking.
I wrote a small open-source CLI to make that a single command. It's an  AWS sample on GitHub , MIT-0 licensed, and it runs straight from  npx  with nothing to install:
npx github:aws-samples/sample-multi-account-bedrock-quota-increase \
--start-url https://my-org.awsapps.com/start \
--accounts 111111111111,222222222222,333333333333 \
--llm global.anthropic.claude-opus-4-8 \
--input-tpm 4000000 --output-tpm 400000 \
--justification "#Adoption\nWe expect heavy usage of our new product"
For each target account, the tool does two things: it enables model access by invoking the model once, and it submits your quota increase through the  AWS Service Quotas API . Then it hands you back a run ID you can use to list, comment on, or close every case the run produced. Let me walk through the parts that turned out to be more interesting than I expected.

No preconfigured profiles — it runs the SSO flow itself

The first friction point in any multi-account tool is credentials. I didn't want to make you set up thirty named profiles in  ~/.aws/config  or get  aws sso login  working first. So the tool runs the  IAM Identity Center OAuth 2.0 device authorization flow  itself.
You pass your access-portal start URL, approve once in the browser, and the tool exchanges the device code for a short-lived token, then calls   GetRoleCredentials   for each target account.
RegisterClient → StartDeviceAuthorization → (approve in browser) → CreateToken
│
per account: ListAccountRoles → GetRoleCredentials
If you don't pass  --role , it assumes the first permission set available in each account. One browser approval covers the whole fleet.

Choosing the fleet: explicit IDs, an OU, or a tag

You pick target accounts three ways, and they compose:
Method
Flag
Explicit account IDs
 --accounts 111111111111,222222222222 
An Organizational Unit (recursive)
 --ou ou-abcd-11111111 
An account tag filter
 --tag team=ml,env=prod 
The  --ou  and  --tag  selectors resolve through the  AWS Organizations API , so they need  --org-account  — the management or  delegated administrator  account to call Organizations from. Only  ACTIVE  accounts are targeted, nested OUs are walked recursively, and combining  --ou  with  --tag  intersects them. Pass a bare  --ou  with no value and it lists your OUs by full path ( Root / Workloads / Prod ) for arrow-key selection.

Enabling model access by invoking the model — not by checking availability

This is the part I went back and forth on the most, and it's worth explaining because it runs against the obvious approach.
Serverless third-party Bedrock models — Anthropic Claude among them — are transacted through AWS Marketplace and need a foundation-model agreement on the account before they can be invoked. Under Bedrock's current  simplified model access , that agreement is created automatically the first time you invoke the model — AWS's own docs note the subscription "initiates in the background" on that first call.
The tempting way to "check access" is   GetFoundationModelAvailability  . I tried it. It lies — not maliciously, but it answers a different question than the one you care about. Against a live test account:
GetFoundationModelAvailability(anthropic.claude-3-haiku-…, us-east-1)
→ agreement AVAILABLE, entitlement AVAILABLE, authorization AUTHORIZED

Converse(same model)
→ ResourceNotFoundException: "This Model is marked by provider as Legacy and
you have not been actively using the model in the last 30 days."
Availability said yes while the model was actually EOL and uninvocable. The only thing that answers "can this account invoke this model right now?" is invoking it. So that's what the tool does — it sends a one-token   Converse   probe:
await runtime.send(new ConverseCommand({
modelId: invokeId,
messages: [{ role: "user", content: [{ text: "Reply with only: ok" }] }],
inferenceConfig: { maxTokens: 5 },
}));
A successful probe proves access; on a genuinely fresh account, that first call also creates the Marketplace agreement as a side effect. Providers not sold through Marketplace (Amazon, Meta, Mistral, DeepSeek, Qwen, OpenAI) need no agreement, so that step is simply skipped. Don't want the tool invoking at all?  --no-subscribe  submits only the quota request;  --subscribe-only  enables access without requesting an increase.

The inference-profile prefix isn't guessable

There's a subtle trap here. Most current Claude models reject invocation by their base id:
Converse(anthropic.claude-sonnet-4-5-…-v1:0, us-east-1)
→ ValidationException: "Invocation with on-demand throughput isn't supported.
Retry with the ID or ARN of an inference profile that contains this model."
You have to invoke through a  cross-region inference profile  — and the regional prefix is not something you can string-build:
Region
Regional profile prefix
us-east-1
 us. 
eu-central-1
 eu. 
ap-southeast-2
 au.  (not  apac. )
So rather than guess, the tool calls   ListInferenceProfiles  , matches each profile's underlying model ARN against the model you asked for, and ranks the matches: active regional profile first, then active  global. , then anything. Whatever it resolves is what it invokes.

The quota request: fuzzy matching, then your confirmation

Bedrock quota names are per-model free text, and there's no stable id-to-quota mapping. A single model might expose:
Cross-region model inference tokens per minute for Anthropic Claude Opus 4.8
Cross-region model inference input tokens per minute for Anthropic Claude Opus 4.8
Cross-region model inference output tokens per minute for Anthropic Claude Opus 4.8
You choose which dimensions to raise — the tool only touches the ones you pass a flag for ( --rpm ,  --tpm ,  --input-tpm ,  --output-tpm ), and at least one is required. For each, it fuzzy-matches the quota by tokenizing both the model name and the quota name, dropping noise words ( the ,  for ,  model ,  inference ,  cross ,  region …) so the model family and version — "opus", "4.8" — are what actually discriminate. Version-bearing tokens are weighted highest, and the profile scope implied by your model id ( global.  vs regional) breaks ties.
Then, unless you pass  --yes , it shows you the matched quota and value and waits for you to approve or edit before anything is submitted. If you'd rather skip matching entirely, pass the quota codes explicitly with  --quota-code L-XXXX,… .
For an adjustable quota,   RequestServiceQuotaIncrease   submits the request and AWS opens the backing Support case for you — no support plan required. For a non-adjustable quota, the tool falls back to opening a Support case directly (which does need a  Business or Enterprise Support plan ).

Run markers: acting on 30 cases as one unit

Submitting the requests is only half the job. A week later you want to nudge them, or close the ones you filed as a test. Every backing case a run creates gets stamped with a marker comment:
[bqi:run=<id>]
The run ID prints to stdout (all the human-readable logs go to stderr, so you can capture just the ID in a script), and a manifest is saved under  ~/.bqi/runs/<id>.json . That marker is what lets you treat the whole fleet as one unit:
# See every case the run opened, with live pending/resolved state
npx github:aws-samples/sample-multi-account-bedrock-quota-increase list \
--start-url "$URL" --run "$RUN_ID"

# Add the same note to every case
npx github:aws-samples/sample-multi-account-bedrock-quota-increase comment \
--start-url "$URL" --run "$RUN_ID" \
--body "Following up — launch is next week, please prioritize."

# Close every case in the run
npx github:aws-samples/sample-multi-account-bedrock-quota-increase close \
--start-url "$URL" --run "$RUN_ID" --yes
There's a nice bit of resilience here: because the marker lives in the case itself, you can act on a run from a different machine that has no local manifest — add  --accounts  and the tool rediscovers the run's cases by scanning for the marker through the Support and Service Quotas APIs. Delete  ~/.bqi/  entirely and your runs are still recoverable.
One honest limitation worth calling out: AWS doesn't expose the approve/deny decision for a Bedrock quota case through either API, so  list  reports only whether the backing case is open ( pending ) or closed ( resolved ) — not whether the increase was granted. For the decision, or to answer a question AWS asked, you still open the case in the console.

Try it without touching anything

The whole thing is safe to explore.  --dry-run  prints exactly what would happen — arg parsing, the resolved model, the generated run marker, one line per quota per account — and makes zero AWS calls, so it needs no credentials and no support plan:
npx github:aws-samples/sample-multi-account-bedrock-quota-increase request --dry-run \
--start-url https://example.awsapps.com/start \
--accounts 111111111111,222222222222 \
--llm global.anthropic.claude-opus-4-8 \
--input-tpm 4000000 --output-tpm 400000 \
--justification "#Adoption\nExpecting heavy usage"
If you want to know when to raise your quotas in the first place — before the throttles start — pair this with its companion sample,  sample-amazon-bedrock-ops-alert , which watches Bedrock usage and alerts as you approach your limits. See where you're running out of headroom, then raise the ceiling across the fleet in one command.
The code is on GitHub:  aws-samples/sample-multi-account-bedrock-quota-increase . It's a sample, not a product — fork it, read it, and adapt it to how your org is structured. Adding a new model is a one-line row in   src/models.ts  , or skip the catalog and pass any inference-profile id with  --llm .
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article