Concurrency & rate limits

"Authorization: Bearer $AISEARCH_API_KEY" ```
</CodeGroup>

See the [async status reference](/api-reference/async-status) for the full response.

## Recommended backoff strategy

<Steps>
<Step title="Honor Retry-After">
  On any `429`, wait at least the number of seconds in `Retry-After` before
  retrying. This is the single most important rule — it aligns your retries
  with when capacity actually frees up.
</Step>
<Step title="Add exponential backoff with jitter">
  If a limit persists, grow the wait between attempts (for example 1s, 2s, 4s,
  8s) and add a little randomness so batched clients don't retry in lockstep.
  Cap the number of attempts.
</Step>
<Step title="Use idempotencyKey for safe retries">
  Set the `idempotencyKey` body field on submissions. If a retry lands after
  the original was already accepted, the same job is returned instead of
  creating a duplicate — so retries can't double-charge credits.
</Step>
<Step title="Prefer webhooks over tight poll loops">
  Instead of polling `GET /v1/jobs/:id` in a tight loop (which burns your
  request rate), submit async with a webhook and let completions come to you.
  Reserve polling for occasional reconciliation.
</Step>
</Steps>

<Warning>
Tight poll loops are the most common cause of self-inflicted
`RATE_LIMIT_EXCEEDED`. If you must poll, space it out and back off — or switch
to [webhooks](/guides/webhooks).
</Warning>

## Node retry-with-backoff

A minimal client that honors `Retry-After`, falls back to exponential backoff, and reuses an `idempotencyKey` so retries are safe:

<CodeGroup>
```javascript retry.js
const API_KEY = process.env.AISEARCH_API_KEY;

async function submitWithRetry(body, { maxAttempts = 5 } = {}) {
// Reuse one key across all retries of this submission.
const idempotencyKey = crypto.randomUUID();

for (let attempt = 0; attempt < maxAttempts; attempt++) {
const res = await fetch("https://api.aisearchapi.dev/v1/search", {
method: "POST",
headers: {
Authorization: `Bearer ${API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ ...body, idempotencyKey }),
});

  if (res.status !== 429) return res; // success or a non-retryable error

  // Honor Retry-After when present; otherwise exponential backoff with jitter.
  const retryAfter = Number(res.headers.get("Retry-After"));
  const backoff = Number.isFinite(retryAfter) && retryAfter > 0
    ? retryAfter * 1000
    : (2 ** attempt) * 1000 + Math.random() * 250;

  await new Promise((r) => setTimeout(r, backoff));

}

throw new Error("Exhausted retries after repeated 429 responses");
}

const res = await submitWithRetry({
query: "best noise-cancelling headphones under $300",
surfaces: ["chatgpt", "perplexity"],
regions: [{ country: "US" }],
});
const job = await res.json();
console.log(job.jobId, job.status);