Rate limits and usage

Two separate limits apply: how many requests a key can send per minute, and how many generations you can run at once.

Request limits

Requests	Limit
Creating jobs, estimates, uploads and other writes (`POST`, `PATCH`, `DELETE`)	120 per minute, per key
Reads (`GET`)	600 per minute, per key

Every response carries:

Header	Meaning
`X-RateLimit-Limit`	Requests allowed in the current window for this kind of request.
`X-RateLimit-Remaining`	Requests left in the window.
`X-RateLimit-Reset`	Seconds until the window resets.

Over the limit you get 429 rate_limited with a Retry-After header in seconds. Wait that long, then retry with the same Idempotency-Key. A long-poll (GET /v1/jobs/{id}?wait=25) is one request however long it waits, so it’s the cheapest way to wait for a job.

Concurrency

You can run as many generations at once as your plan’s parallel generations. The limit is per person, not per key or per workspace, and it’s shared with the Voyager app: jobs you start from the app, the dashboard, a connected AI and the API all count toward the same number.

Plan	Parallel generations
Starter	6
Creator	12
Ultra	24
GigaMax	36

voyager.so/pricing has the current plans. GET /v1/account returns your limit as limits.concurrency.parallel_generations. Speech and 3D jobs also share a workspace-wide cap that counts every member’s jobs together, on top of your own limit: limits.concurrency.workspace.speech and limits.concurrency.workspace.3d. A job over either cap waits queued.

The queue

Creating a job while you’re at your limit doesn’t fail: the job is accepted as queued and starts when one of yours finishes.

You can have up to 100 active jobs (queued plus running) at once, counted per person across all your workspaces. Past that, create returns 429 queue_full and nothing is accepted; the Idempotency-Key stays reusable.
A job that waits more than 1 hour without starting is canceled with error.code queue_timeout. Nothing is charged.

Credits and your account

GET /v1/account shows the workspace, plan, credits available and your limits:

curl https://api.voyager.so/v1/account -H "Authorization: Bearer $VOYAGER_API_KEY"

An example (values are illustrative):

{
  "object": "account",
  "workspace": { "id": "team_01JB…", "name": "Northlight Films" },
  "api_key": { "id": "key_01JC…", "name": "my-app-prod" },
  "plan": { "key": "creator", "name": "Creator", "paid": true },
  "credits": { "available": …, "unit": "credits" },
  "limits": {
    "requests_per_minute": { "write": 120, "read": 600 },
    "concurrency": { "scope": "user", "parallel_generations": 12, "workspace": { "speech": …, "3d": … } },
    "queue": { "max_queued": 100, "max_queued_age_seconds": 3600 }
  }
}

Field	Type	Description
`object`	`string`	Always “account”. Always `account`.
`workspace`	`Workspace`	The workspace this key belongs to.
`api_key`	`ApiKeyInfo`	The key making this request.
`plan`	`Plan`	The workspace’s Voyager plan.
`credits`	`Credits`	The workspace’s credit balance.
`limits`	`Limits`	Rate, concurrency and queue limits that apply to this key.

plan:

Field	Type	Description
`key`	`string` or `null`	free, starter, creator, ultra or gigamax; null when the workspace has none.
`name`	`string` or `null`	The plan’s name; null without one.
`paid`	`boolean`	Whether new generations and uploads are allowed through the API.

credits:

Field	Type	Description
`available`	`integer` or `null`	The workspace’s credit balance, as its Voyager dashboard shows it; null when it could not be read.
`unit`	`string`	Always “credits”. Always `credits`.

limits:

Field	Type	Description
`requests_per_minute`	`RequestsPerMinute`	Requests this key may make per minute.
`concurrency`	`Concurrency`	Jobs that may run at once.
`queue`	`Queue`	Jobs that may wait at once, and for how long.

limits.requests_per_minute:

Field	Type	Description
`write`	`integer`	Per key: creates, estimates, uploads and other writes.
`read`	`integer`	Per key: every GET.

limits.concurrency:

Field	Type	Description
`scope`	`string`	Counted per person across the app, the MCP and every one of their keys; not per workspace. Speech and 3D jobs are also bounded by a workspace-wide cap on those job types. Always `user`.
`parallel_generations`	`integer` or `null`	Generations running at once; more wait queued.
`workspace`	`WorkspaceConcurrency`	Speech and 3D jobs also share a workspace-wide cap.

limits.concurrency.workspace:

Field	Type	Description
`speech`	`integer`	Speech jobs running at once across the workspace.
`3d`	`integer`	3D jobs running at once across the workspace.

limits.queue:

Field	Type	Description
`max_queued`	`integer`	Active jobs (queued plus running) one person may have at once, across workspaces; a create beyond it is 429 queue_full and nothing is accepted.
`max_queued_age_seconds`	`integer`	A job queued longer is canceled (error.code queue_timeout).

Credits are shared across the workspace: the app, the dashboard, connected AIs and the API all draw from the same Voyager credits. Running jobs hold credits until they settle, so credits.available drops when a job starts. Prices are on voyager.so/pricing.

Usage per key

The API tab on voyager.so/dashboard/api shows credits used by each key over the last 30 days and when each key was last used. Every job created with a key is counted against that key, including its later settlement and any refunds. Workspace-wide usage, across the app and the API, is on the dashboard’s usage page.

Avoid hitting limits

Wait with ?wait=25 or webhooks, not tight polling loops. Honor poll_after_ms and Retry-After.
Read X-RateLimit-Remaining and slow down before you reach zero.
Batch work by creating jobs at a steady pace; extra jobs queue on their own.
Use separate keys per app so one busy integration doesn’t use up another’s request limit. They still share your parallel generations.

Get started

Concepts

Reference

Cloud machines

API reference

Rate limits and usage

Request limits

Concurrency

The queue

Credits and your account

Usage per key

Avoid hitting limits

​Request limits

​Concurrency

​The queue

​Credits and your account

​Usage per key

​Avoid hitting limits

Request limits

Concurrency

The queue

Credits and your account

Usage per key

Avoid hitting limits