Key points
- Separate pagination, concurrency, credit budget and destination capacity.
- Inspect effective page size before continuing a changed allowance.
- Choose recovery from the actual failure instead of retrying every request.
Pagination and request controls solve different problems. Pagination chooses the next part of a lead result set; concurrency and retry rules control how much work your integration starts and how it responds to failure.
For Dievio, build around numeric pages and a separate API credit balance. Do not invent a universal requests-per-minute limit, daily reset or rate-limit response header when the current contract does not document one.
Separate the limits before writing the worker
| Control | What it governs | Owner |
|---|---|---|
| Page size | Records requested in one source operation | Your request within the supported contract |
| Result cap | The upper bound for the extraction job | Your job definition |
| Concurrency | Source operations running at the same time | Your integration |
| Provider traffic policy | Documented or observed service constraints | The provider contract and response guidance |
| Credit budget | Paid retrieval the account can fund | Your balance and operating approval |
| Destination capacity | CRM writes or other downstream actions | The destination contract and your queue |
A credit error is not evidence of temporary traffic throttling. Dievio's current public-search route can return 402 when the request cannot proceed with the available API credits. Repeating the same call in a tight loop will not restore that balance.
Use numeric pages without assuming cursor guarantees
Public search accepts _page, _per_page and max_results. Its response includes preview_data, has_more and next_page. The pagination implementation guide explains the checkpoint loop.
Keep filters and page size fixed within one job. Store the successful response before recording the page as complete. An opaque cursor and a numeric page are different contracts; neither should be assumed to guarantee a stable snapshot unless that guarantee is documented.
Begin with bounded, observable work
Start with a deliberately limited job and enough visibility to explain every source attempt. Increase parallel work only after observing latency, errors, account balance and downstream queue growth for the actual audience.
- Set a maximum number of concurrent source requests.
- Keep source retrieval separate from CRM write workers.
- Bound request time, retry attempts and the total job duration.
- Stop automatically on repeated unexplained responses or a budget boundary.
- Give paused jobs an owner and a clear recovery condition.
A faster request loop can increase cost without improving accepted output. Measure the whole handoff, including duplicates, missing fields and review effort, rather than celebrating raw rows per second.
Choose recovery from the failure category
| Observation | Useful next action |
|---|---|
| Missing or rejected credentials | Inspect authentication and approved key configuration before retrying |
| Credit failure | Pause and review balance, job scope and the response message |
| Invalid request or schema | Correct the request against the documented contract |
| Temporary service failure | Use a bounded retry policy with backoff and a stop condition |
| Timeout with an uncertain result | Reuse the same page parameters and its saved Idempotency-Key within the replay window. If the first request had no key, check the job log and credit activity before retrying. |
| Destination failure after stored retrieval | Recover the destination action from stored records |
Some providers return 429 or a Retry-After value. Follow the response and its documentation when present; do not assume Dievio always emits those fields. The HTTP specification defines the retry field as a delay or an HTTP date.
Use backoff without hiding repeated failure
When the same keyed page is still running, Search returns HTTP 409 with Retry-After. Wait for that delay, then retry with the original key and parameters. HTTP 409 without that header signals that the key was used with different parameters. Use a fresh key for a different logical page. Read the Search API retry rules.
For recoverable failures, increase the delay between attempts, add jitter where useful and cap both attempts and elapsed time. An endless retry loop is a stalled job, not resilience.
A circuit breaker can pause new attempts after a sustained failure pattern. Keep its recovery probe small and observable. Do not restart every pending page at once when the pause ends.
For implementation details, read the error handling and retry guide. Record provider-specific behavior separately from general HTTP design.
Keep repeated retrieval out of destination recovery
A successful search followed by a failed CRM import leaves useful source data in your storage. Retry the failed write using that stored response when its use remains appropriate. A second search can return overlapping records and spend credits again.
Store source attempt references, returned row counts, checkpoints and destination outcomes. Redact credentials and unnecessary contact details from logs. The credit consumption guide should be read alongside the operation's actual billing rules.
Review a completed run before scaling it
- Reconcile requested scope, stored pages and reported completion.
- Count unique accepted records and unresolved identity conflicts.
- Check repeated source requests and why each happened.
- Compare available balance and observed paid usage.
- Inspect destination backlog and failed actions.
Scale the bottleneck you can demonstrate. If the destination is already behind, increasing source concurrency only adds pressure and makes recovery harder to reason about.



