{{ summaryTitle }} {{ summaryValue }} {{ summaryLine }} {{ badge.label }}{{ badge.value }}

Rate-limit pacing and retry policy inputs
Use the work waiting in the batch, queue, or recovery run.
requests
The pacing plan treats this as the total allowance shared by all modeled clients.
req/min
No planned retry occurs before this minimum wait.
sec
Choose a whole number from 1 through 20.
retries
Use the retry library default or the provider's documented recommendation.
ms
A value of 2 is classic exponential backoff.
x
The cap must be at least the base delay.
ms
Full jitter is a strong default when many clients can fail together.
This budget covers planned waiting, not request execution time.
sec
Disable automatic retry when replay could duplicate a side effect.
{{ retry_safe ? 'Idempotent or protected' : 'Duplicate-side-effect risk' }}
{{ workflowFeedback }}
Leave blank for a neutral “API” label; do not enter tokens or customer identifiers.
One client is neutral; larger values widen per-client pacing and increase no-jitter contention risk.
clients
Leave blank to omit the status-set audit, or list values such as 429, 500, 502, 503, 504.
{{ planExportStatus }}
Plan itemValueOperational useCopy
{{ row.item }}{{ row.value }}{{ row.note }}
{{ scheduleExportStatus }}
AttemptDelay windowExpected waitCumulative expectedCopy
{{ row.attempt }}{{ row.window }}{{ row.expected }}{{ row.cumulative }}
{{ safetyExportStatus }}
CheckStateNext actionCopy
{{ row.check }}{{ row.state }}{{ row.action }}
{{ chartExportStatus }}

A rate-limited service needs fewer requests, not a faster loop of retries. When many clients receive the same rejection and retry together, they can create another burst as soon as the wait ends. A recovery plan must control both the delay before each retry and the ordinary pace of new requests.

Exponential backoff increases the client-side delay after each failed attempt, usually until a maximum is reached. Jitter spreads clients across a delay window so they do not all wake at the same instant. A server-provided Retry-After value acts as a floor: no planned retry should occur before that wait has elapsed.

  • Pacing spreads the normal request volume across the shared allowance.
  • Backoff increases waits after repeated transient failures.
  • Jitter gives concurrent clients different retry times within a safe window.
  • Retry safety asks whether replaying the operation could duplicate a side effect.

The HTTP status alone does not make an operation safe to replay. A read or an idempotency-key-protected write may tolerate automatic retries. An unprotected payment, order, message, or mutation can run twice if the first response is lost after the server completed the work. Authentication, validation, and permission failures also need correction rather than repeated requests.

A retry budget provides a separate stopping rule. The total expected waiting must fit inside the caller timeout, queue visibility window, job lease, or other deadline, while still leaving time for the requests themselves. A schedule that fits the wait budget can still fail if network and execution time consume the remainder.

Backoff arithmetic is a planning envelope, not a promise about recovery. Provider quotas may be global, per account, per route, or weighted by request cost. Live response headers and provider documentation remain the authority for the actual limit and reset behavior.

How to Use This Tool:

Start with the shared quota and caller deadline, then model only failures that are safe to retry.

  1. Enter Requests to send and the Shared rate limit, then set Concurrent clients to the callers sharing that allowance.
  2. Enter the server's Retry-After floor when one is known. Leave it at zero only when no floor is being modeled.
  3. Set Retry attempts, Base delay, Backoff multiplier, Maximum client delay, and the Jitter policy.
  4. Enter the Caller retry budget. Zero disables the comparison; a positive value covers planned waiting but not request execution time.
  5. Switch Automatic retry safety off when replay could duplicate a side effect, then review the schedule and safety result before copying the policy into a client.

Interpreting Results:

Expected total wait is the sum of the midpoint of every modeled delay window. The minimum and maximum totals show the envelope around that midpoint. They are planning values, not sampled retry times.

Global request spacing is the average interval for the whole quota. Per-client spacing assumes the allowance is divided evenly among all entered clients. Coordinated pacing is still needed; independent clients cannot safely infer a global quota from their own local counters.

  • Unsafe operation takes priority when automatic replay is not protected.
  • Budget exceeded means expected waiting is strictly greater than the positive caller budget.
  • Contention risk appears when more than one client uses no jitter.
  • Schedule ready means those modeled guardrails pass, not that the provider guarantees success.

Technical Details:

The delay schedule combines a capped client backoff with an optional server floor. Attempt numbering starts at one, while the exponential index starts at zero. Every window is deterministic; “expected” means the midpoint between its modeled minimum and maximum.

Formula Core

For attempt index i, base delay B, multiplier m, and maximum delay C, the ordinary client ceiling is:

ci=min(C,B×mi)

Let R be the entered Retry-After floor in milliseconds. Each jitter policy turns the ceiling into a minimum and maximum delay:

Retry delay bounds by jitter policy
PolicyMinimumMaximumExpected
No jittermax(R, cᵢ)Same as minimumSame as minimum
Full jitterRmax(R, cᵢ)(minimum + maximum) / 2
Equal jittermax(R, cᵢ / 2)max(R, cᵢ)(minimum + maximum) / 2
Decorrelated estimatemax(R, B)max(minimum, R, cᵢ)(minimum + maximum) / 2

For the decorrelated estimate only, the ceiling is recalculated from the previous expected delay e, then capped:

ci=min(C,max(B,3×ei1))

Cumulative expected wait is the running sum of each midpoint. A positive caller budget is exceeded only when that sum in seconds is greater than the entered budget; equality still fits.

Texpected=i=0A1ei

Pacing and Status Rules

For Q requests, a shared limit L per minute, and N concurrent clients, the even pacing values are:

Tpace=QL×60 sglobal=60L sclient=sglobal×N

The safety status follows a strict order: unsafe replay, then exceeded budget, then multi-client contention without jitter, then ready. Listing status 429 records whether it appears in the policy audit but does not change delay arithmetic.

Limitations and Accuracy Notes:

The schedule models client waits and an even quota pace. It does not call the service, read live headers, sample random delays, or include request execution time.

  • The entered Retry-After value is a delay in seconds; date-form response values must be converted before use.
  • Decorrelated jitter is a deterministic midpoint envelope, not the sequence a production random number generator will produce.
  • Quota scope, request weights, sliding windows, token buckets, and provider-specific reset rules can differ from a simple requests-per-minute allowance.
  • Retry only documented transient failures and operations that are idempotent or otherwise protected from duplicate side effects.

Worked Examples:

Shared clients with a server floor

For three attempts with a 500 ms base, 2× multiplier, 5,000 ms cap, 0.5 second server floor, and equal jitter, the delay windows are 500–500 ms, 500–1,000 ms, and 1,000–2,000 ms. Their expected waits total 2.75 seconds. A 3 second retry budget therefore leaves 0.25 second for the modeled wait, but request execution time still needs separate room.

References: