AI News
14 Dec 2025
Read 8 min
Increase timeout for third-party requests: 5 quick fixes
increase timeout for third-party requests to prevent HTTP 500s and keep external content loading now.
When calls to external APIs stall, apps break. The fastest fix is to increase timeout for third-party requests, then add guardrails. Raise client and proxy limits, use retries with backoff, shift slow work to background, tune connections, and add fallbacks. These steps cut errors without hurting users.
Modern apps depend on outside services for payments, maps, emails, and more. When those services respond slowly, your app may show errors or spin forever. A few quick changes can stabilize your stack and keep users moving. Below are five fixes you can apply today, in order of impact and safety.
Client libraries: Set connect timeout to 2–5 seconds and read timeout to 15–60 seconds.
Reverse proxies and gateways: Bump NGINX proxy_read_timeout or HAProxy timeout server to match your client.
Serverless and workers: Ensure your function or job worker timeout is higher than the API read timeout.
Provider knobs: Some APIs let you pass a query parameter like timeout=50000 to allow longer processing on their side.
Make sure all layers align. If your browser waits 30 seconds but your proxy drops after 10, users still get errors. Also split timeouts:
Connect timeout (fast fail on bad networks)
Read timeout (more generous for slow backends)
Do not rely on default settings. Defaults vary by library and can be too low for large exports or too high for quick UI calls. Document your standards per endpoint type.
Use exponential backoff with jitter (for example, 0.5s, 1s, 2s, add random jitter).
Retry on 429 and 5xx status codes, and on connect or read timeouts.
Respect Retry-After headers when present.
Cap attempts (2–3 tries) and set an overall deadline so you do not hang forever.
Retry only idempotent calls (GET, safe POSTs with idempotency keys).
Combine retries with a slightly higher timeout to smooth brief spikes. This is often the lowest-effort way to increase timeout for third-party requests without hurting UX.
Queue long jobs (reports, imports, video processing) and return a task ID immediately.
Show progress in the UI and poll or use webhooks to update status.
Use background workers with a higher per-job timeout than your web requests.
For mobile and frontend, lazy-load nonessential data after the main view renders.
This pattern protects the user journey. You can still increase timeout for third-party requests behind the scenes, but the main experience stays fast and responsive.
Enable connection reuse (keep-alive) and HTTP/2 to cut handshake costs.
Lower DNS and connect delays with DNS caching and short connect timeouts.
Reduce payload size: request only needed fields, use pagination, compress JSON, and gzip responses.
Batch small calls when possible, or parallelize independent calls.
Pick regional endpoints close to your servers to reduce latency.
Trim every millisecond you can. A smaller, closer, compressed response means fewer timeouts and less pressure to push limits higher.
Use a circuit breaker to fail fast after repeated errors, then try again after a cool-down.
Serve cached or “stale-while-revalidate” data if fresh data is slow or down.
Show defaults or degraded UI (e.g., hide map tiles but keep addresses).
Warm caches for critical pages at deploy time to prevent cold-start delays.
Log, trace, and alert on timeout rates and latency percentiles (p95, p99).
These patterns protect your app and your users, even when a provider has a bad day.
A small checklist to close:
Decide per-endpoint budgets: fast UI calls (5–10s total), heavy jobs (60–300s in background).
Set and document timeouts at every layer.
Add retries with backoff and jitter.
Shift long work off the request/response path.
Measure, cache, and fail gracefully.
Wrap-up: You do not need to overhaul your stack to stabilize outside calls. First, increase timeout for third-party requests in a careful, layered way. Then add retries, async workflows, network tuning, and fallbacks. With these five quick fixes, your app will feel faster and fail less, even when partners slow down.
Raise the limit: how to increase timeout for third-party requests safely
Start by increasing the timeout where the call is made. Keep it reasonable, not infinite. Aim for a short connect timeout and a longer read timeout.Add smart retries with exponential backoff
Many timeouts are temporary. A retry can turn a failure into a success, if you do it right.Move slow calls off the critical path
Not every task must finish during a page load or button click.Tune the network path and your HTTP client
Sometimes you do not need a bigger timeout—you need a faster call.Add fallbacks, circuit breakers, and caching
Even with bigger timeouts and retries, outages happen. Plan graceful failure.(Source: https://www.theverge.com/news/841431/figma-ai-editing-tools-erase-isolate-object)
For more news: Click Here
FAQ
Q: What is the fastest fix when external API calls stall?
A: The fastest fix is to increase timeout for third-party requests and then add guardrails like raising client and proxy limits, using retries with backoff, shifting slow work to background, tuning connections, and adding fallbacks. These steps cut errors without hurting users.
Q: How should I set timeouts across clients, proxies, and serverless functions?
A: When you increase timeout for third-party requests, keep values reasonable and split them into a short connect timeout and a longer read timeout. For client libraries, set connect timeout to 2–5 seconds and read timeout to 15–60 seconds, and make sure reverse proxies and serverless function timeouts align with the API read timeout.
Q: What are best retry practices for handling temporary timeouts?
A: Use exponential backoff with jitter and retry on 429 and 5xx status codes as well as on connect or read timeouts, while respecting Retry-After headers. Cap attempts to 2–3 tries and set an overall deadline, and retry only idempotent calls or those with idempotency keys. Combine retries with a slightly higher timeout to increase timeout for third-party requests without hurting UX.
Q: How can I move slow third-party calls off the critical user path?
A: Queue long jobs and return a task ID immediately, use background workers with a higher per-job timeout, and show progress in the UI with polling or webhooks. You can still increase timeout for third-party requests behind the scenes, but shifting slow work off the request/response path keeps the main experience fast and responsive.
Q: What network and HTTP client tuning reduces timeout risk?
A: Enable connection reuse (keep-alive) and HTTP/2, use DNS caching to lower DNS and connect delays, and prefer regional endpoints to cut latency. Also reduce payload size with pagination and compression, and batch or parallelize calls where appropriate.
Q: Which fallbacks should I implement if a provider is unreliable?
A: Use a circuit breaker to fail fast after repeated errors and serve cached or stale-while-revalidate data when fresh responses are slow or down. Even after you increase timeout for third-party requests and add retries, show degraded UI, warm critical caches at deploy time, and log, trace, and alert on timeout rates and latency percentiles.
Q: How long should timeouts be for quick UI calls versus heavy background jobs?
A: Decide per-endpoint budgets: aim for fast UI calls to complete in about 5–10 seconds total and run heavy jobs in the background with budgets of roughly 60–300 seconds. Set and document timeouts at every layer so all parts of the stack align.
Q: How should I monitor timeouts and related latency issues?
A: Log and trace timeout rates and latency percentiles such as p95 and p99, and set alerts on those metrics to catch provider slowdowns early. Also measure, cache, and fail gracefully, and document timeout standards so incidents are easier to diagnose.
Contents
