Limits and usage
Your account's tier sets a per-minute rate limit and a daily budget of credits, split into a data pool and an AI pool;
GET /v1/account/usage shows what is left. Keys are in Authentication and keys.
Tiers
Every key and the website session of an account share its limits, so a second key never adds capacity. A new account is on the default tier.
| tier | code | for | credits per UTC day | requests per minute | AI work in progress at once | archive allowance |
|---|---|---|---|---|---|---|
| Standard (default) | standard | the default tier: data, AI, the MCP server, and application sessions | 10,000 (data 3,000, AI 7,000) | 60 | 4, at most 2 of them research runs | 1 GiB |
| Enterprise | enterprise | organizations with allowances by agreement | by agreement | by agreement | by agreement | by agreement |
GET /v1/auth/tiers lists the tiers; it is public. The archive allowance is the bytes your account can keep in its
session archives; deleting a session frees its bytes.
How credits are counted
Data requests and AI work are paid in credits. Each tier's daily credits are split into pools: data requests draw on the data pool and AI work (research runs, copilot runs, and model inference) on the AI pool. A spent pool does not draw on the other. The rate card:
| use | credits |
|---|---|
| one data request | 1 |
| 1,000 input tokens | 10 |
| 1,000 output tokens, including the model's reasoning | 50 |
Charges are exact to 0.01 credit; nothing is rounded.
A data request costs its credits when it is admitted. AI work holds a reservation while it runs; when it ends, you are charged the credits it used, which can be more or less than the reservation. Work cut off before it reports its usage is charged the reservation (settlement).
Each AI response reports the tokens it used in usage.
Rate limit
The per-minute limit covers every authenticated request in a sliding 60-second window. Route responses and
429 rate_limit_exceeded carry these headers; a request refused earlier (key, entitlement, or spent pool)
may not:
| header | meaning |
|---|---|
x-ratelimit-limit | requests allowed in any 60 seconds |
x-ratelimit-remaining | the limit less your requests in the last 60 seconds; it rises again as older requests leave the window |
x-ratelimit-reset | 60 on an admitted request; on a refused one, the seconds until your oldest counted request leaves the window |
A tool call to the hosted MCP server counts twice against this limit, and any other MCP request (connecting, listing the tools) once. Only the HTTP request a tool call makes is charged; listing the tools costs no credits.
A connected app (one you signed in to the MCP server, rather than gave a key) also has a limit per connection at the
server: a burst of 120 requests, refilled at 2 a second. Over it, the server answers 429 rate_limit_exceeded with
Retry-After: 5. A connection made with an API key has only your per-minute limit.
The public routes need no key and never draw on a pool. /openapi.json is limited to 30 requests a
minute per client address; over that you get 429 rate_limit_exceeded with Retry-After.
Daily credits
The pools count per UTC day and reset at midnight UTC. A response that draws on a pool carries X-Quota-Pool (the
pool it drew on), X-Quota-Limit, X-Quota-Remaining (the limit less settled charges) in credits, and X-Quota-Reset,
the time the pool resets.
Every data read is a data request, including reading a stored research report or digest. A request refused as
malformed (422 invalid_request) counts too; one refused for its key (401, 403) or a spent pool does not.
Exceeded limits
You get 429: rate_limit_exceeded for the per-minute limit, and quota_exhausted when the pool a request draws on is
spent, with pool, remaining, and resets_at in the error. After rate_limit_exceeded, retry after Retry-After;
after quota_exhausted, do not retry before resets_at (X-Quota-Reset). The other pool may still have credits. AI
work refused at admission charges nothing.
Charges for AI work
A unit of AI work is a research run, including one the copilot starts as a tool, a copilot run, or a model-inference request. New work is admitted while the AI pool's settled charges are below its allowance. A unit in progress does not count until it settles, and work already running is never cut off, so the pool can end the day over its allowance by what the units then in progress settle.
- A research run reserves 3,932.16 credits.
- A copilot run reserves the credits of 196,608 input tokens and of its output limit (
max_output_tokens, 16,384 by default): 2,785.28 credits by default. - A model-inference request reserves the credits of its input, estimated from the request's size, and of its output limit (model inference limits).
One unit costs at most 5,242.88 credits for a research run, 8,028.16 for a copilot run, and 3,932.16 for model inference.
Settlement
When the work ends, its reservation is replaced by the settled charge:
| work | settled charge |
|---|---|
| a research run or model inference that finishes | the credits of the input and output the model reported |
| copilot run | each model call's reported input and output; a call cut off part-way counts its estimated input and its output limit |
| a research run or model inference that fails after the model has started | the credits of the input and output the model reported, or 0 if it reported none |
work that produces nothing (refused, model unavailable), or a research run that ends before its model_started event | 0 |
| a research run or model inference cut off without a usage report (cancel, closed connection, timeout), or a copilot run whose usage is lost | the whole reservation |
A research run charged its whole reservation reports basis: reservation with measured_output_tokens null.
Concurrent AI work
Your tier sets how many AI units can be in progress at once: research runs, copilot runs, and model-inference requests that are admitted and not yet settled.
- Standard: 4, at most 2 of them research runs
- Enterprise: by agreement
One more is refused 429 concurrency_limit_reached with limit and in_flight in the error and Retry-After: 5.
A research run the copilot starts is refused as a tool error inside the run instead, and the run continues.
Check your usage
GET /v1/account/usage shows, under account, your tier, each credit pool in pools (its allowance, used for settled charges, and held for the reservations of work
still running), your rate and concurrency limits, your archive storage, and resets_at. It charges nothing. Every field
is described in the API reference. The usage page (tauric.ai/settings/usage) shows
your tier, rate limit, credit pools, archive storage, credit rates and reset time.
Response caching
A few slowly changing reads carry Cache-Control: private, max-age=3600, so your application may reuse them for an
hour: the classification lists (/v1/taxonomy, /v1/securities/sectors, /industry-groups, /industries,
/sub-industries, /exchanges), the dataset catalog (/v1/datasets and one dataset), and a security's profile. A
reused copy costs nothing.
Cache per caller (key or session) and per full request; never share a copy across callers.