
AI video batch generation is queued because submitting jobs and running jobs are separate steps: your provider accepts the whole batch at once, but a concurrency limit caps how many tasks generate simultaneously. Requests above that cap receive THROTTLED status and wait in line, so a 50-video batch completes in waves, not in parallel.
Key takeaways:
- Runway's API Tier 3 allows five concurrent tasks and a US$2,000 monthly spending cap, reached immediately after US$100 has been purchased, per its usage-tier documentation.
- Requests above the applicable concurrency limit receive THROTTLED status and wait for processing rather than failing.
- Actual concurrency can occasionally fall below the listed maximum under system load, so a documented ceiling is not a throughput guarantee.
- More API credit raises your spending capacity but does not raise the concurrency ceiling that determines how fast a batch drains.
What is the difference between batch submission and concurrent generation?
Batch submission is the act of sending many generation requests in one call or script loop; concurrent generation is how many of those requests the provider processes at the same time. The two are independent. Runway's API accepts your entire batch immediately, then admits tasks into active processing only up to your tier's concurrency limit. At Tier 3, that limit is five tasks, with a US$2,000 monthly spending cap, and the tier is reached immediately after US$100 has been purchased, according to Runway's usage-tier documentation. A 40-video batch submitted at 9:00 is therefore five videos generating and 35 waiting, not 40 videos generating.
This distinction matters because most deadline math goes wrong here. Creators measure one video's generation time, multiply nothing, and assume the batch finishes in roughly that time. The correct mental model is a queue: total time approximates batch size divided by concurrency, multiplied by average per-task time, plus variance.

What does THROTTLED mean in an AI video API?
THROTTLED is a queue status, not an error. Runway's documentation states that requests above the applicable concurrency limit receive THROTTLED status and wait for processing, per its usage tiers page. A throttled job is accepted, held, and admitted to active generation as soon as a concurrency slot frees up. Your batch is not broken; it is lined up.
The practical implication: do not retry or resubmit THROTTLED jobs. Resubmitting duplicates the request and can push the new copy to the back of the line while the original still holds its place. Poll status, wait, and let the queue drain.
Can I have spending capacity left but still hit a concurrency limit?
Yes, because spending caps and concurrency limits are separate constraints that throttle different things. Runway's Tier 3 pairs a US$2,000 monthly spending cap with a concurrency limit of five tasks, per its usage-tier documentation. The spending cap governs how much you can pay for in a month; the concurrency limit governs how many tasks run at once. You can have US$1,900 of headroom left and still watch job six sit in THROTTLED status while five tasks run.
Concurrency and budget are independent limits; headroom in one does not lift the other.
| Runway API Tier 3: two separate ceilings | |
|---|---|
| Concurrent tasks | 5 |
| Monthly spending cap (US$) | 2,000 |
| Spend to reach tier (US$) | 100 |
Does buying more API credit always make a batch finish faster?
No. Buying credit raises spending capacity, and on some tiers it unlocks a higher tier with a higher concurrency limit, but credit alone does not widen the pipe. Runway notes that actual concurrency can occasionally fall below the listed maximum because of system load, and that its hypothetical processing-time calculation is not a measured turnaround guarantee, per its usage tiers page. Even at a paid-up tier, a batch can run slower than the documented ceiling suggests.
Treat the concurrency number as a best case, not a service level. If a client deadline depends on the listed maximum holding for six straight hours, the plan has no margin for the slowdowns the provider itself warns about.
How should I estimate a batch deadline when processing times vary?
Estimate with a queue model and add headroom on top. The formula: expected batch time equals (number of videos divided by concurrency) multiplied by your measured average per-video time, then multiplied by a safety factor of 1.5 to 2 to absorb system-load slowdowns and failed generations.
Worked example: 30 Shorts, five concurrent slots, a measured average of four minutes per video. The naive estimate is (30 / 5) x 4 = 24 minutes. The planned estimate is 24 x 1.5 = 36 minutes, and you promise delivery after 48. If the batch finishes in 26 minutes, nothing is lost; if system load halves effective concurrency, you still ship on time. Creators who track per-video timing as part of their production records can refine that average every batch instead of guessing.

What should I measure in a small test before scheduling a large batch?
Run a pilot batch of five to ten videos and record four numbers: submission-to-start latency, per-video generation time, end-to-end batch wall-clock time, and failure or retry count. These give you a measured average and a measured variance, which replace the provider's hypothetical timing example with your own data. Adobe gives the same advice for its repeatable Firefly Graph workflows: test with minimal input before scaling, because charges and behavior can vary with execution.
Action: submit the pilot at the same time of day you plan to run the real batch, since system load varies.
What it requires: a timestamp log per job, which any script or spreadsheet can capture.
How to tell it worked: your predicted batch time lands within your safety factor on the first full run.
An orchestration layer can make this repeatable. GoFaceless (our own product) turns a topic or brief into a finished short-form video, script through captions, in one pass, which suits preparing standardized, repeatable jobs; the underlying generation providers can still impose queues and concurrency limits, so the measurement discipline above applies either way. If you are also deciding how jobs should be submitted, the trade-offs in AI voiceover API vs web app map closely onto video batches.
The one rule: schedule to the queue, not the ceiling
A documented concurrency limit is a ceiling on simultaneous work, not a promise of throughput. Measure your own completion times with a pilot batch, model the batch as a queue, and multiply by a safety factor before you commit to a delivery time. Creators who do this miss deadlines rarely; creators who multiply one video's time by nothing miss them on schedule.
If you want the preparation side handled, GoFaceless turns a topic into a finished faceless video, script, voiceover, visuals, and captions, so your batch jobs start standardized. See plans and pricing to match a tier to your batch volume.
Sources & further reading
Keep reading

AI Voiceover API vs Web App: Which Fits Your Workflow?
AI voiceover API vs web app: compare retry rules, revision costs, and logging overhead, with a decision table and a low-risk pilot plan for creators.

How to Make an AI Video Follow Your Script Word for Word
How to make an AI video follow your exact script: choose an exact-script workflow over prompt generation, then verify narration and captions against approved text.

AI Content Disclosure Rules for Video Creators
Learn the AI content disclosure rules for YouTube, EU audiences, advertising, labels, monetization, and realistic AI-generated visuals.
