getYour application
Enqueue a versioned tool call through the TypeScript or Python SDK.
DURABLE EXECUTION / CUSTOMER-OWNED WORKERS
Make tool calls durable. Keep recovery deliberate.
Make tool calls and background operations durable. Queue the work, run it in your own workers, and control what happens when it fails.
TypeScript & Python · At-least-once execution
Your application
enqueue()GetRatchet
persist · schedule · inspectYour workers
claim · execute · reportWork persists through failure.
Persist the job. Schedule retries. Inspect every attempt.
Accelerated example · at-least-once executionYour code stays in your infrastructure.
GetRatchet coordinates execution. Your workers make the actual calls, with your credentials and your deployment choices.
GetRatchet
Persist the job, schedule attempts and track the execution history.
Your worker
Claim work, call your provider and report the result with a lease token.
Retry the failures that can recover.
Use Standard, Aggressive or Relaxed backoff. With Basic and Pro, define a Custom policy: attempts, initial delay, multiplier, cap and jitter. Each job keeps its policy snapshot.
Read the worker guide429 / rate limited
RetryableError with retryAfterMs respects the provider’s minimum wait.
503 / unavailable
RetryableError schedules another attempt within the policy limit.
400 / invalid input
NonRetryableError stops automatic attempts. Fix the input before replay.
Unknown handler errors are retryable by default. Classify third-party errors locally with classifyError; do not send raw exception objects.
From first call to recovery
See the path an operation takes.
Example path: bounded retries, circuit cooldown, then reviewed replay. External side effects still require destination-side idempotency.
Illustrative run · sync_invoice@1
An execution, with a way back.
- Queued
Input accepted and persisted.
- Running
A worker claims a time-limited lease.
- Retrying
HTTP 503. Handler marks the failure retryable.
Policy delay: 10s · ±20% jitter - Failed
Attempts exhausted. Automatic retries stop.
- Blocked
Open circuit holds further work.
- Succeeded
A permitted probe succeeds after cooldown.
- Recovered
Operator-approved replay succeeds.
Failure is a state you can inspect.
See attempts, worker leases and failure context. Pause an endpoint, let its circuit cool down, or review a replay before it runs.
Circuit breakers
Repeated failures open the circuit. A controlled probe checks recovery after cooldown.
Replay safeguards
Review input and handler version, acknowledge duplicate risk, then request another execution.
Operational evidence
Inspect run history and export telemetry from your workers. Paid plans add alerts and bulk recovery.
The same operation. Two SDKs.
Start a run, enqueue a versioned handler, then finish submitting work. A registered worker executes it asynchronously.
TypeScript
import { createRatchet } from '@getratchet/sdk';
const ratchet = createRatchet({
baseUrl: 'https://getratchet.app',
apiKey: process.env.GETRATCHET_INGEST_KEY!,
});
await ratchet.startRun('Customer onboarding');
await ratchet.enqueue({ customerId: 'cus_2048' }, {
name: 'send_welcome_email', version: '1', endpoint: 'Email service',
idempotencyKey: 'welcome:cus_2048', timeoutMs: 30_000, maxAttempts: 5,
});
await ratchet.finishRun();Python
import os
from getratchet import Ratchet
ratchet = Ratchet('https://getratchet.app', os.environ['GETRATCHET_INGEST_KEY'])
ratchet.start_run('Customer onboarding')
ratchet.enqueue(
'send_welcome_email', '1', {'customerId': 'cus_2048'},
idempotency_key='welcome:cus_2048',
)
ratchet.finish_run()The key identifies this business operation. Pass it to the destination service too; a worker can finish an external action before its success report arrives.
Keep the handler. Retire the retry plumbing.
For a short, disposable operation, an in-process retry may be enough. Use durable execution when unfinished work and recovery history matter.
| Concern | Built in your application | With GetRatchet |
|---|---|---|
| Process restart | Persist and recover unfinished work yourself. | Durable queue, leases and attempt history. |
| Provider outage | Coordinate backoff, caps and circuit state. | Policy snapshots and circuit gates. |
| Failed work | Build inspection and replay tooling. | Inspect a run and review its replay. |
| External side effects | Use destination-side idempotency. | Still use destination-side idempotency. |
Controls you can reason about.
Scoped API keys. Role-based access. Encrypted durable inputs and replay results. Redacted inspection views. Revocable sessions. These are controls, not a claim of certification.
Optional AI advisory summarizes bounded operational evidence. Deterministic checks and human approval control recovery; advice cannot schedule a replay.
Read data handling and security detailsStart with a real workload.
Every plan uses your own workers. Choose capacity and recovery controls, not a different execution model.
FREE
$0/ month
50,000 attempts / UTC month
BASIC
$29/ month
500,000 attempts / UTC month
PRO
$99/ month
2,000,000 attempts / UTC month
Before you put work in the queue.
Does GetRatchet run my code?
No. You deploy TypeScript or Python workers. GetRatchet stores and coordinates jobs; your workers execute the registered handlers.
Is execution exactly once?
No. Execution is at least once. A lost report can cause another attempt after an external action succeeded. Use destination-side idempotency for side effects.
Can I decide which errors retry?
Yes. RetryableError, NonRetryableError and a local error classifier control retry decisions. A retry-after hint sets a minimum delay, up to the 24-hour safety limit.
What happens at a plan limit?
New work is blocked at the allowance or unfinished-work limit. Already accepted jobs can finish. There are no automatic overage charges.
Design for the next failure.
Give your next operation a recovery path.
Create a workspace, register a worker, and inspect your first durable run.