What you will be able to do
- Identify whether request rate, input tokens, output tokens, or cost is the binding constraint on a Claude workload
- Tell a rate-limit 429 apart from a ramp-limit 429 and a spend-cap 429, and respond to each one correctly
- Raise effective throughput with prompt caching and model routing before asking for higher limits
- Design queues that pace traffic and keep live requests separate from bulk work
- Design Message Batches pipelines within their size, time, and parameter limits
- Isolate tenants and teams with workspace limits, and plan capacity from usage charts
Key concept
Per-model token-bucket limiters — Each model class has three separate limiters: requests per minute, uncached input tokens per minute, and output tokens per minute. Each one refills continuously, and whichever runs out first sets your throughput. Scaling a Claude workload starts with working out which of the three is binding, or whether the real limit is cost.
1.Three limiters per model class, set at the organization level
A high-volume Claude service fails in predictable ways once one limiter runs dry. The Messages API measures each model class on three axes: requests per minute (RPM), input tokens per minute (ITPM), and output tokens per minute (OTPM). Going over any one of them returns a 429 that names the limit you hit. All three apply to the whole organization, so issuing more API keys inside the same organization adds no capacity. Every key draws from the same buckets.
The limiters work as token buckets. Capacity refills continuously up to the maximum instead of resetting at the top of each minute. They can also be enforced over intervals shorter than a minute: a 60 RPM limit might be enforced as one request per second. A short burst can therefore trigger 429s even when the per-minute average is well under the limit. A scheduler that fires 600 jobs at second zero of every minute hits this, even with a 1,000 RPM ceiling.
| Model | RPM | ITPM | OTPM |
|---|---|---|---|
| Claude Fable 5.2 | 4,000 | 500,000 | 100,000 |
| Claude Opus 5.5 | 4,000 | 2,000,000 | 400,000 |
| Claude Sonnet 5.5 | 4,000 | 2,000,000 | 400,000 |
| Claude Haiku 5.5 | 4,000 | 2,000,000 | 400,000 |
| Claude Opus 4.x (combined) | 1,000 | 2,000,000 | 400,000 |
Separate buckets per model give you a lever that costs nothing. Suppose a pipeline's first step, intent classification, uses 60% of a mid-tier model's input tokens, and an offline eval shows a smaller model class is just as accurate. Moving that step to the smaller model shifts its tokens into a different bucket and frees the mid-tier model's ITPM for the steps that need it. The alternatives do worse. Merging four steps into one long prompt cuts the request count, but RPM was not the problem and the tokens are still sent. Truncating context frees capacity at the cost of answer quality. Asking for higher limits leaves a proven improvement unused.
Checkpoint 1 of 10· Check yourself
A pipeline on Claude Sonnet 5.5 keeps getting 429s on its input-tokens-per-minute (ITPM) limit. An intent-classification step uses 60% of that model's input tokens, and an offline eval shows Claude Haiku 5.5 classifies just as accurately. Which change frees Sonnet 5.5 input capacity without lowering answer quality?
Each model row has its own token buckets, so moving the step to Haiku 5.5 moves its tokens out of the Sonnet 5.5 ITPM bucket. Extra API keys draw from the same organization-level buckets. Merging prompts reduces requests, not tokens. Cutting context costs answer quality.
“Each row in the following tables has its own RPM, ITPM, and OTPM limits. Some rows cover several models that share one limit”Source: platform.claude.com
Checkpoint 2 of 10· Exam question
Indigo Legal runs a four-step contract-review pipeline in production: intent classification, clause extraction, risk scoring, and summary drafting. All steps share one mid-tier model, and the pipeline now regularly hits that model's input-token limit during business-hour peaks, causing queued and delayed reviews. Token logs show intent classification consumes 60% of all input tokens, because every incoming document is classified in full. An offline evaluation on a labeled sample of past documents shows a smaller model class matches the mid-tier model's classification accuracy. The later three steps need deep reasoning over the whole document, and the team has seen quality drop whenever they were combined in one prompt. What is the best change?
Correct answer: A — Route step one to the smaller model class, which has its own separate limits, and keep the later steps on the mid-tier model.
- A. Correct. Limits are per model class, so shifting the cheap high-volume step relieves the saturated pool and cost, backed by the eval.
- B. A merged prompt does not reduce total tokens meaningfully and raises risk of quality loss in steps that need isolation.
- C. Truncation can drop signal that classification needs and is not validated by the eval described.
- D. The eval does provide a reason; waiting on a limit increase ignores a cheaper validated fix.
Sources1
2.What counts toward ITPM and OTPM
ITPM counts only uncached input, so prompt caching is the strongest throughput lever you control. Tokens after the last cache breakpoint count, and so do tokens being written to the cache. Tokens read from the cache do not. With a 2,000,000 ITPM limit and an 80% cache hit rate, you can process about 10,000,000 input tokens per minute: 2M uncached plus 8M read from cache. The cached tokens are billed at the cache-read rate, which is a fraction of the base input price.
| Usage field or parameter | Counts toward | Consequence for design |
|---|---|---|
| input_tokens (after last cache breakpoint) | ITPM | Shrink it by moving static content before a breakpoint |
| cache_creation_input_tokens | ITPM | A cache write costs ITPM once; later reads are free against ITPM |
| cache_read_input_tokens | Nothing (not ITPM) | A higher cache hit rate raises effective input throughput |
| Generated output tokens | OTPM, evaluated in real time | Only tokens actually produced count |
| max_tokens | Nothing | No rate-limit downside to a generous value |
In the document-QA case, the other fixes target limiters that are not binding. Lowering max_tokens changes nothing, because OTPM counts only the tokens actually generated and max_tokens is not part of the calculation. Spacing 40 requests evenly across the minute helps an RPM problem, but 40 RPM is nowhere near the request limit. The manual is input whether it sits in the system prompt or the user message. The fix is to cache it.
Checkpoint 3 of 10· Match them up
A capacity planner is reading the usage object on a cached Messages API response. Match each field or parameter to how it counts against the rate limiters.
Tap a term, then the definition that fits it.
ITPM counts uncached input and cache writes, but not cache reads. OTPM counts only the output tokens actually generated, and max_tokens does not count toward any limiter. So a cache write costs ITPM once, and later reads of that content are free against ITPM.
“cache_creation_input_tokens (tokens being written to cache) ✓ Count toward ITPM”Source: platform.claude.com
Checkpoint 4 of 10· Exam question
Marlow Freight runs a production document-QA service for its customs-compliance staff. Every call sends the same 30k-token policy manual, which is revised only quarterly, plus a short employee question, and the answers are brief. Compliance requires the full manual to be in context on every call, so trimming it or retrieving excerpts is not allowed. Traffic is 40 requests per minute, far under the request limit, and peaks last several minutes rather than arriving as brief spikes, yet 429s appear at peak. Response headers show input-token capacity near zero while output-token capacity is barely used, and request-count headroom stays large throughout. Which change most directly raises effective throughput?
Correct answer: B — Add a cache breakpoint after the static manual, so repeat calls read it from the prompt cache and those reads are not counted toward the input-token limit.
- A. Lowering
max_tokensonly shrinks the output-token reservation, and the headers show the output pool is barely used. The input-token pool, drained by the 30k manual on each call, is untouched. - B. Correct. Cache-read tokens do not count toward the input-token limit, so caching the static 30k manual removes most of the load that is exhausting that pool and lets more requests through.
- C. Forty requests per minute is far below the request limit, so the request counter is not the bottleneck. Even spacing leaves the same 30k manual in each call and the input-token pool still runs dry.
- D. Where the manual sits in the prompt does not change how it is counted. System and user content are both input tokens, so the same 30k tokens still draw on the exhausted input-token pool.
Sources1
3.Reading a 429 to find the binding constraint
Not every 429 means "slow down and retry." Three different conditions share the rate_limit_error type, and the right response differs for each. Check error.details.error_code and the response headers before you decide what to do. General retry mechanics, such as backoff, jitter and SDK retry settings, belong to retry and error handling. This section covers diagnosing which limit you hit.
A plain rate limit names the RPM, ITPM or OTPM limit you exceeded and usually carries a retry-after header. A ramp limit (ramp_limit_exceeded) fires when your usage on a model grows sharply, even while you are under ITPM and OTPM. A spend-cap 429 (enforced_spend_limit_reached) means the organization has reached its tier's monthly cap. It has no retry-after, and every retry fails until access resumes or the organization moves to a higher tier. A spend limit that you set yourself, below the cap, returns HTTP 400 invalid_request_error, not a 429.
{
"type": "error",
"error": {
"type": "rate_limit_error",
"message": "You have reached your API usage limits: your organization has crossed its monthly API usage threshold, set based on your organization's API tier. You will regain access on 2026-09-01 at 00:00 UTC.",
"details": { "error_code": "enforced_spend_limit_reached" }
},
"request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}Headers show which bucket is empty. anthropic-ratelimit-requests-remaining, anthropic-ratelimit-input-tokens-remaining and anthropic-ratelimit-output-tokens-remaining each report what is left, and token counts are rounded to the nearest thousand. Input remaining near zero with output untouched points to ITPM: cache more or route some traffic to another model. Requests remaining at zero at the start of each minute points to RPM and bursty scheduling: pace the load.
Sometimes no rate limit is binding at all. Take a nightly job that classifies 200,000 documents through the synchronous API, uses 35% of ITPM, never sees a 429, and needs results by 08:00. Its constraint is cost. A higher tier raises limits the job never reaches. Splitting the calls across several API keys changes neither the limits nor the price, because limits are set per organization. The fix is the Message Batches API, which bills every token at 50% of standard prices and fits easily inside an overnight window.
| Symptom | Binding constraint | First fix |
|---|---|---|
| Requests remaining hits zero at the start of each minute | RPM over a short interval | Spread requests evenly |
| Input tokens remaining near zero, output barely used | ITPM | Cache static prefixes; move a step to another model class |
| 429 with ramp_limit_exceeded while under ITPM/OTPM | Ramp limit | Hold load, then grow by one step per minute |
| 429 with enforced_spend_limit_reached | Monthly spend cap | Move to a higher tier; retries will not help |
| No 429s, deadline is hours away, spend too high | Cost | Message Batches API |
Checkpoint 5 of 10· Check yourself
Partway through the month, every call from a reporting service starts failing with HTTP 429. The error type is rate_limit_error, error.details.error_code is enforced_spend_limit_reached, and there is no retry-after header. The SDK's automatic retries have been running for an hour without a single success. What should the team do?
enforced_spend_limit_reached means the organization hit its tier's monthly spend cap. It has no retry-after, so retries and pacing cannot help until access resumes or the organization moves to a higher tier. A spend limit the team set themselves returns HTTP 400 invalid_request_error, not a 429. Pacing and step-by-step growth are the fixes for RPM and ramp limits.
“Retrying, including the SDK’s automatic retries, fails until access resumes.”Source: platform.claude.com
Checkpoint 6 of 10· Exam question
Orchid Health runs a nightly job that classifies 200,000 clinical-intake documents with the synchronous Messages API, routing each to a triage category. The job starts at 22:00 and currently finishes around 02:00. Its results feed a report that staff open at 08:00 the next morning, and nobody reads individual outputs before then. Monitoring shows the job uses about 35% of its input-token capacity and has never received a 429. Each call already returns only a short category label, and the whole organization shares one account and one pooled spend. Finance has asked engineering to reduce the nightly spend without changing the model or the classification quality. Which change best addresses the binding constraint?
Correct answer: B — Move the calls to the Message Batches API, so results arrive asynchronously and each token is billed at a discounted rate.
- A. A higher tier raises rate limits but leaves the per-token price unchanged. The job uses about 35% of its input capacity and never gets a 429, so throughput is not the constraint, and finishing sooner does not lower the bill.
- B. Correct. Results are not needed until 08:00 and nothing is rate-limited, so the real lever is price. The Message Batches API processes requests asynchronously at a discounted per-token rate, which fits a nightly job that can wait.
- C. A classifier already returns a short label, so a lower cap saves almost nothing and risks truncating outputs. Most of the cost is the input tokens of 200,000 documents, which the cap does not touch, and the per-token price stays the same.
- D. Rate limits and pricing apply at the organization level, so extra keys change neither. The job never receives a 429, so there is no limit to work around, and each token costs the same however many keys send it.
4.Queueing, pacing and backpressure
A queue in front of Claude exists to turn uneven demand into the steady flow that token buckets reward. The ramp limit makes this concrete. It sits at your recent peak per-minute usage plus a step, rises by at most one step per minute as successful usage grows, and falls back after a quiet period. A bulk job that starts at full speed against a cold model can hit 429s at a fraction of its rate limit. The prescribed recovery is to wait at least the retry-after seconds, hold traffic where requests succeed, and then grow by at most one step per minute.
Backpressure means letting the API's own signals control dispatch. When several teams share an organization's limits, spare capacity changes through the day. A fixed concurrency is then either too high, producing 429s whenever a neighbor runs a big job, or too low, leaving capacity idle. A dispatcher that reads the -remaining headers and honors retry-after can cut concurrency as headroom shrinks and raise it as headroom returns, and the work queue absorbs the difference.
Live traffic and bulk traffic need separate lanes. A single FIFO queue that feeds a user-facing feature and a reprocessing job on the same model makes users wait behind thousands of bulk items. Put live requests in their own queue with first claim on synchronous capacity. Move the bulk work to the Message Batches API, which has its own limits shared across all models and is not subject to ramp limits.
Checkpoint 7 of 10· Put it in order
A bulk job has just started at full speed on a model it has not used recently, and its requests are returning 429s while usage is well under ITPM and OTPM. Put the recovery steps in order.
- 1.Wait at least the number of seconds in the retry-after header before sending again
- 2.Increase load by at most one step per minute as successful usage grows
- 3.Read error.details.error_code and confirm it is ramp_limit_exceeded, not a plain rate limit or the spend cap
- 4.Resume at a traffic level where requests succeed and hold it there
The error_code shows this is a ramp limit, so retrying is worthwhile, unlike after the spend cap. After waiting out retry-after, hold traffic at a level that succeeds. The ramp limit then rises by at most one step per minute above recent peak usage, so load can grow only that fast.
“Hold your traffic at a level where requests succeed, then increase it by at most one step per minute.”Source: platform.claude.com
Sources1
5.Designing Message Batches pipelines
Use the Message Batches API when results can wait. Its economics are simple: all usage costs 50% of standard prices, and most batches finish within an hour. Results become available once every request has completed, or after 24 hours, whichever comes first. Requests that are still unprocessed at 24 hours expire. When demand is high, processing can slow down and more requests may expire, so a pipeline with a hard deadline should submit early and handle expired requests.
| Model | Batch input | Batch output |
|---|---|---|
| Claude Fable 5.2 | $4 / MTok | $20 / MTok |
| Claude Opus 5.5 | $2 / MTok | $10 / MTok |
| Claude Sonnet 5.5 | $1 / MTok | $5 / MTok |
| Claude Haiku 5.5 (prompts up to 100,000 tokens) | $0.05 / MTok | $0.25 / MTok |
Size and retention limits determine how a pipeline divides its work. One batch holds at most 100,000 requests or 256 MB, whichever comes first. Batches have their own RPM limit and a cap on how many batch requests can sit in the processing queue at once, so a large backlog has to be submitted in waves. Results are kept for 29 days, so download them well before then. Each request carries a custom_id of 1 to 64 characters (letters, digits, hyphens, underscores), and your pipeline uses it to match results back to source records.
Almost any Messages request can go in a batch, including tool use, vision, extended thinking and multi-turn conversations, and request types can be mixed in one batch. A few parameters are rejected with a validation error: stream: true, speed (fast mode), fallbacks, and max_tokens: 0 for cache pre-warming. Because batches run with high concurrency, they can go slightly over a workspace's configured spend limit. Leave margin under any limit you set for a workspace that runs batches.
Checkpoint 8 of 10· Check yourself
Your team is moving a nightly document-review job from the synchronous Messages API to the Message Batches API. Which part of the current request design has to change before the batch will be accepted?
stream: true is one of the few parameters a batch rejects with a validation error, because batch results come back as a single file. Tool use, multi-turn conversations, extended thinking and mixed request types are all allowed. A custom_id made of letters, digits, hyphens and underscores, up to 64 characters, is valid.
“stream: true | Batch results come back as a single file, not a stream.”Source: platform.claude.com
Sources2
6.Multi-tenant quota and isolation with workspaces
Workspaces are how one organization divides its limits among products, environments or tenants. Each workspace can have its own monthly spend limit and its own RPM, ITPM and OTPM limits per model. These limits only work downward. A workspace limit keeps one workload from consuming capacity the others need, but it cannot give any workload more than the organization has. The Rate Limits API will accept a workspace value above the organization limit, but the lower of the two is what gets enforced.
A common layout gives development lower rate limits, staging production-like limits, and production the full limits. Each organization can have up to 100 active workspaces by default. Some resources are scoped to a workspace, including Message Batches, so a batch created in one workspace is visible only there. Claude Code gets its own automatically created workspace. Its usage is rate-limited separately, and admins can cap its share of the organization's limits.
client = anthropic.Anthropic()
rows = client.beta.organization.analytics.usage.list(
starting_at="2026-09-01T00:00:00Z",
ending_at="2026-09-08T00:00:00Z",
time_bucket_width="1d",
workspace_ids=["wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"],
group_by=["workspace_id"],
)
for row in rows:
print(f"{row.starting_at} {row.group.workspace_id}: {row.usage.total_tokens}")2,000,000. The API stores the higher value but enforces the lower of the workspace and organization limits. Production still shares that 2,000,000 with every other workspace that has no lower cap of its own.
Checkpoint 9 of 10· Fill the gap
A platform team bills each tenant's product for the Claude usage in that tenant's own workspace. Which parameter name completes this Usage and Cost Analytics call so it returns usage for that one tenant?
client = anthropic.Anthropic()
rows = client.beta.organization.analytics.usage.list(
starting_at="2026-09-01T00:00:00Z",
ending_at="2026-09-08T00:00:00Z",
time_bucket_width="1d",
? =["wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"],
group_by=["workspace_id"],
)
for row in rows:
print(f"{row.starting_at} {row.group.workspace_id}: {row.usage.total_tokens}")Workspaces divide an organization's limits and spend among tenants, so you filter by workspace ID (the wrkspc_ prefix) and group by workspace_id to see each tenant's usage. API keys are not the unit of isolation, because every key draws from the same organization-level limits.
Source: platform.claude.comSources3
7.Capacity planning for growth and launches
Plan capacity from the Usage page's rate-limit charts. The input chart shows the hourly maximum of uncached input tokens per minute, your current ITPM limit, and your cache rate. The output chart shows the hourly maximum of output tokens per minute against your OTPM limit. Peak usage, not average usage, is what you compare to the limit.
Work through a launch that will triple traffic in three weeks, starting from 85% peak ITPM usage and a 20% cache rate. Tripling without changes would put you far over the limit. Raising the cache rate is the first lever, because every input token moved from uncached to cache-read leaves the ITPM count. The second step is to request higher limits for whatever headroom caching cannot cover, early enough that they are in place before launch. Plan for launch day itself too. A sudden jump in traffic can hit the ramp limit even after your rate limit is raised, so release traffic in steps where you can.
Every published limit is a maximum, not a guaranteed minimum. An organization that needs guaranteed capacity can buy a Priority Tier commitment: a set number of input and output tokens per minute on a specific model version, for 1 to 12 months. Requests over the commitment fall back to standard tier. Cache reads count as 0.1 tokens against Priority capacity, so caching stretches a commitment as well. Priority Tier does not cover the 5.x models, including Opus 5.5, Sonnet 5.5 and Haiku 5.5. Cost modeling beyond the batch discount is covered in cost architecture.
Checkpoint 10 of 10· Check yourself
Three weeks before a launch that will triple traffic, a Claude Sonnet 5.5 service peaks at 85% of its ITPM limit with a 20% cache rate. Which capacity plan holds up?
Cache reads leave the ITPM count, so raising the cache rate is the first lever. Higher limits cover what is left. A sudden jump can still hit the ramp limit after a raise, so traffic goes out in steps. Priority Tier does not cover the 5.x models. Planning should use peak usage, not the average. Workspace limits can only lower capacity, not raise or reserve it.
“With effective caching, you can substantially increase your actual throughput without raising your rate limits.”Source: platform.claude.com
Sources
(4)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.https://platform.claude.com/docs/en/api/rate-limitsOfficial docs
“The API uses the token bucket algorithm to do rate limiting.”
↩︎ Three limiters per model class, set at the organization level“a rate of 60 requests per minute (RPM) might be enforced as 1 request per second”
↩︎ Three limiters per model class, set at the organization level“Each row in the following tables has its own RPM, ITPM, and OTPM limits.”
↩︎ Three limiters per model class, set at the organization level“Opus rate limit is a total limit that applies to combined traffic across Claude Opus 4.8, Opus 4.7, Opus 4.6, and Opus 4.5.”
↩︎ Three limiters per model class, set at the organization level“cache_read_input_tokens (tokens read from cache) ✗ Do NOT count toward ITPM”
↩︎ What counts toward ITPM and OTPM“With effective caching, you can substantially increase your actual throughput without raising your rate limits.”
↩︎ What counts toward ITPM and OTPM“The max_tokens parameter does not factor into OTPM rate limit calculations”
↩︎ What counts toward ITPM and OTPM“If you exceed any of the rate limits, you get a 429 error describing which rate limit was exceeded.”
↩︎ Reading a 429 to find the binding constraint“The error type is rate_limit_error, the same as for a rate limit, but the response has no retry-after header.”
↩︎ Reading a 429 to find the binding constraint“When usage reaches a spend limit you set, requests return HTTP 400 with error type invalid_request_error.”
↩︎ Reading a 429 to find the binding constraint“The number of input tokens remaining (rounded to the nearest thousand) before being rate limited.”
↩︎ Reading a 429 to find the binding constraint“After a sharp increase in usage, requests can return a 429 error even while you’re under your ITPM and OTPM rate limits.”
↩︎ Queueing, pacing and backpressure“Hold your traffic at a level where requests succeed, then increase it by at most one step per minute.”
↩︎ Queueing, pacing and backpressure“Start scheduled or bulk jobs at a low rate and spread requests evenly, rather than sending everything at once.”
↩︎ Queueing, pacing and backpressure“The Message Batches API isn’t subject to ramp limits.”
↩︎ Queueing, pacing and backpressure“Use these charts to see what headroom you have to grow, identify when you might be hitting peak use”
↩︎ Capacity planning for growth and launches“All limits described here represent maximum allowed usage, not guaranteed minimums.”
↩︎ Capacity planning for growth and launches“Each row in the following tables has its own RPM, ITPM, and OTPM limits.”
↩︎ Key concept“Limits are set at the organization level.”
↩︎ Exam trap 1“The max_tokens parameter does not factor into OTPM rate limit calculations”
↩︎ Exam trap 2“Retrying, including the SDK’s automatic retries, fails until access resumes.”
↩︎ Exam trap 3“Each row in the following tables has its own RPM, ITPM, and OTPM limits. Some rows cover several models that share one limit”
↩︎ Checkpoint“cache_creation_input_tokens (tokens being written to cache) ✓ Count toward ITPM”
↩︎ Checkpoint“Retrying, including the SDK’s automatic retries, fails until access resumes.”
↩︎ Checkpoint“With effective caching, you can substantially increase your actual throughput without raising your rate limits.”
↩︎ Checkpoint - 2.
“All usage is charged at 50 percent of the standard API prices.”
↩︎ Reading a 429 to find the binding constraint“A Message Batch is limited to either 100,000 Message requests or 256 MB in size, whichever is reached first.”
↩︎ Designing Message Batches pipelines“Batches expire if processing does not complete within 24 hours.”
↩︎ Designing Message Batches pipelines“Batch results are available for 29 days after creation.”
↩︎ Designing Message Batches pipelines“batches might go slightly over the spend limit configured in the Claude Console for your Workspace.”
↩︎ Designing Message Batches pipelines“stream: true | Batch results come back as a single file, not a stream.”
↩︎ Designing Message Batches pipelines“Must be 1 to 64 characters and contain only alphanumeric characters, hyphens, and underscores”
↩︎ Designing Message Batches pipelines - 3.
“Workspace limits can keep a workspace below your organization’s limits, but they can’t raise those limits”
↩︎ Multi-tenant quota and isolation with workspaces“which stores a value above the organization’s limit but still enforces the lower of the two.”
↩︎ Multi-tenant quota and isolation with workspaces“Claude Code usage is rate-limited separately, and admins can cap its share of the organization’s limits under Rate limits in the Claude Console.”
↩︎ Multi-tenant quota and isolation with workspaces“Message Batches created through the Batch API”
↩︎ Multi-tenant quota and isolation with workspaces“Workspace limits can keep a workspace below your organization’s limits, but they can’t raise those limits”
↩︎ Exam trap 4 - 4.
“Cache reads as 0.1 tokens per token read from the cache”
↩︎ Capacity planning for growth and launches“Requests beyond your committed capacity automatically fall back to standard tier.”
↩︎ Capacity planning for growth and launches