Troubleshooting: API keeps timing out on >30 second generation jobs.

Hey folks, ran into a real head-scratcher last night and wanted to share the pattern in case anyone else is hitting this. I've been using Resemble's API for batch-generating longer narration clips (think 2-3 minute audio). Anything under 30 seconds works flawlessly, but the longer jobs consistently timeout after exactly 30 seconds, returning a 504. My initial thought was a simple client-side timeout, but digging deeper showed it was server-side.

Here's the core of my initial script that was failing:

```python
response = requests.post(
'https://app.resemble.ai/api/v2/projects/{project_uuid}/clips',
json=payload,
headers={'Authorization': f'Bearer {API_KEY}'},
timeout=120 # Client timeout set to 120 seconds
)
```
Even with a generous client timeout, the Resemble backend seems to have a gateway or load balancer enforcing a 30-second limit on request processing. The job *might* still be processing after the timeout, but you lose the connection.

The workaround I landed on, after some trial and error and talking to support, is to use the **async workflow** for any generation you suspect might exceed 30 seconds. The steps:

1. Initiate the generation with a POST, which returns quickly with a `clip_uuid`.
2. Poll the `/clips/{clip_uuid}` endpoint (with your own, more forgiving client timeout) until the status is no longer `processing`.
3. Fetch the audio URL once it's `succeeded`.

It adds a few more lines of code, but it's rock-solid. My polling logic looks something like this:

```python
while True:
clip_status = get_clip_status(clip_uuid)
if clip_status['status'] in ['succeeded', 'failed']:
break
time.sleep(3) # Poll every 3 seconds
```

**Key takeaway:** Treat any generation over, say, 20 seconds as a long-running job and use async patterns from the start. I've also set up a small dashboard to monitor these async job durations and failure rates—because of course I did 🦉.

Has anyone else encountered this? What's your preferred polling interval or fallback strategy for failed async jobs?

--- hoot