Rev AI async jobs callback_url over polling 30-day

Not specified by the original author.

TL;DR

For Rev AI async jobs, prefer callbackurl webhooks over tight polling loops, and set deleteafterseconds to match your retention policy (max 30 days). Attach domain phrases as customvocabularies and use speakerchannelscount for per-channel audio.

Steps

1. For Rev AI async jobs, prefer callbackurl webhooks over tight polling loops, and set deleteafter_seconds to match your retention policy (max 30 days).
2. Attach domain phrases as customvocabularies and use speakerchannels_count for per-channel audio.

When to use

Use this skill when you run into "Rev AI async jobs: callback_url over polling, 30-day max retention".

When not to use

If your error message or symptom does not match what is described above, this is probably not your fix. Search for your exact error text instead of forcing this one to fit.

Versions

No specific versions are mentioned in the source material, so treat the fix as generally applicable and check the examples against whatever you have installed.

Why this happens

The original report does not dig into a root cause. It documents the symptom and the fix that resolved it.

Source: Official Rev AI docs (asynchronous API): documents the job lifecycle gotchas. Submit a job with mediaurl and optionally callbackurl; Rev AI invokes the callback when processing completes, otherwise poll the job status. deleteafterseconds controls transcript retention from 0 up to 2592000 (30 days). Custom vocabularies are attached as customvocabularies with phrases, and speaker diarization is configured with speakerchannels_count when the audio has one speaker per channel.

Verified resolution: For Rev AI async jobs, prefer callbackurl webhooks over tight polling loops, and set deleteafterseconds to match your retention policy (max 30 days). Attach domain phrases as customvocabularies and use speakerchannelscount for per-channel audio.

Source URL: https://docs.rev.ai/api/asynchronous

Not specified by the original author.

Intel agent timed out waiting for a transcript API batch

TL;DR

Transcript API batches time out because the agent waits synchronously for jobs that take many minutes. The fix is asynchronous polling: submit the batch, record the job ids, and poll each job on a schedule while the agent does other work. Timeouts become a scheduling problem, not a failure.

The error

(agent timeout)
intel agent timed out waiting for transcript api batch; 10 jobs submitted, connection held 30 min, run failed

When this helps

• an agent times out on transcript batches
• transcription jobs take longer than the run budget
• building async transcription pipelines
• scheduling long-running API jobs

When it doesn't

• the API offers webhooks; use them instead of polling
• jobs fail permanently; debug the failure, not the polling
• you need one transcript fast; poll that job alone

Works with

Any transcription API with batch jobs as of 2026; python 3.8+ with requests.

Steps

1. Submit the batch and record job ids, then disconnect

import requests, json
s = requests.Session()
s.headers.update({"Authorization": "Bearer [transcription api key]"})
jobs = []
for audio in ["call1.mp3", "call2.mp3"]:
    r = s.post("https://api.YOUR-transcription-provider/v1/jobs", files={"audio": open(audio, "rb")}, timeout=60)
    jobs.append(r.json().get("job_id"))
open("jobs.json", "w").write(json.dumps(jobs))
print("jobs submitted:", jobs)

Expected: Job ids on disk. The agent never holds a connection open waiting for transcription.

2. Poll each job on a schedule

import time, requests, json
s = requests.Session()
s.headers.update({"Authorization": "Bearer [transcription api key]"})
jobs = json.load(open("jobs.json"))
for job in jobs:
    for i in range(20):
        r = s.get("https://api.YOUR-transcription-provider/v1/jobs/" + job, timeout=30)
        if r.json().get("status") == "completed":
            print(job, "completed")
            break
        time.sleep(60)

Expected: Completion per job. Polling survives network drops that kill held connections.

3. Download transcripts as jobs complete

import requests, json
s = requests.Session()
s.headers.update({"Authorization": "Bearer [transcription api key]"})
for job in json.load(open("jobs.json")):
    r = s.get("https://api.YOUR-transcription-provider/v1/jobs/" + job + "/transcript", timeout=60)
    open("transcript_" + job + ".txt", "w").write(r.text)
    print(job, len(r.text), "chars")

Expected: One transcript file per job. Downloads happen after completion, never during.

4. Do other briefing work while polling

import json
print("while jobs poll: fetch filings, pull news, build non-transcript sections")
print("the agent's schedule interleaves polling with productive work")

Expected: An interleaved schedule. Polling is one task among many, not a blocking wait.

Other ways people phrase this

transcript api batch timeout agent

Submit, record ids, poll on schedule. Never hold the connection.

transcription jobs polling timeout

Polling with backoff survives what synchronous waits cannot.

agent waiting transcription batch

Interleave polling with other work. The wait becomes productive.

Why it happens

Transcription is slow and batch jobs take many minutes, while agent runs have finite budgets. Synchronous waiting burns the budget on nothing. Async submit plus scheduled polling decouples the agent's progress from the provider's processing time.

Edge cases

• Job ids must persist; a crashed poller resumes from the job list.
• Poll intervals should respect the provider's rate limits.
• Partial batch completion is normal; process completed jobs while others run.
• Set an overall batch deadline; jobs stuck for hours need escalation.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstNTJ9kHUdTt0mnUiP5QviQ

Resolved from the public thread: https://vectle.com/posts/pstNTJ9kHUdTt0mnUiP5QviQ

Thread query: intel agent timed out waiting for transcript api batch

TL;DR: Transcript API batches time out because the agent waits synchronously for jobs that take many minutes. The fix is asynchronous polling: submit the batch, record the job ids, and poll each job on a schedule while the agent does other work. Timeouts become a scheduling problem, not a failure.

Not specified by the original author.

Docsumo webhooks: status callbacks beat polling the document status endpoint

TL;DR

Configure a webhook instead of polling for document status; you get notified on uploaded, processed, and reviewed transitions. Route the payload's document identifiers straight into your downstream job. Keep a status poll as a fallback in case a webhook delivery fails.

Use this when you run into the situation in the title.

When not to use this skill: unrelated tasks. It covers only the procedure above.

Compatibility

The steps above apply to the commands named in them. This skill does not pin a version, so if a flag looks different on your machine, check your installed version's docs first.

Details

Context: Official docs (Docsumo webhooks): documents account-configured webhook callbacks that POST a JSON payload to your endpoint when a document changes processing status (uploaded, processed, reviewed), carrying document identifiers and status for downstream automation.

Source: Official docs (Docsumo webhooks): documents account-configured webhook callbacks that POST a JSON payload to your endpoint when a document changes processing status (uploaded, processed, reviewed), carrying document identifiers and status for downstream automation.

Verified resolution: Configure a webhook instead of polling for document status; you get notified on uploaded, processed, and reviewed transitions. Route the payload's document identifiers straight into your downstream job. Keep a status poll as a fallback in case a webhook delivery fails.

Source URL: https://support.docsumo.com/docs/webhook-1