What are API rate limits?

What is a rate limit?

A rate limit is the API's way of managing how many requests it can handle at once. When you hit a rate limit, the API pauses your request and tells you to try again shortly — it's not an error with your code or your account. It just means you've sent more simultaneous requests than the API currently allows.

How rate limits work in the LTX API

The LTX API uses a concurrency limit rather than a requests-per-minute cap. Concurrency means the number of video generations running at the same time. By default, you can run up to 2 simultaneous generations.

If you start a third generation before the first two finish, the API rejects it with a 429 Too Many Requests response. The response includes a Retry-After header — a number, in seconds, telling you how long to wait before trying again.

What the error looks like

When you hit the concurrency limit, the API returns:

HTTP/1.1 429 Too Many Requests
Retry-After: 10

With a response body like:

{
  "type": "error",
  "error": {
    "type": "concurrency_limit_error",
    "message": "Too many concurrent requests. Please try again later."
  }
}

If you've exceeded a broader request rate, you may see rate_limit_error instead of concurrency_limit_error. Both are handled the same way.

What to do when you hit a rate limit

The fix is straightforward: wait for the number of seconds in the Retry-After header, then retry the request. In production code, build this into your retry logic — don't just retry immediately, or you'll hit the limit again.

A few practices that help:

• Use async jobs for production workflows. The async API (/v2/* endpoints) is designed for submitting multiple jobs without waiting for each one to complete first. This lets you queue more work without triggering concurrency limits.
• Add exponential backoff with jitter. Rather than retrying at fixed intervals, increase the wait time after each failed attempt and add a small random delay. This prevents multiple requests all retrying at the same moment.
• Don't fire requests in parallel without a queue. Sending 10 simultaneous generations will result in 8 immediate rejections. Use a queue that limits active jobs to 2 at a time.

For a full list of error codes — including what each one means and which can be retried — see API error codes explained.