The exchange, end to end

Observations enter from partner systems and leave as interpretations consumed by external platforms. Select any stage to see its purpose, inputs, outputs, and dependencies.

Your first signal in fifteen minutes

Six steps from credential to qualified signal. Every request runs against the sandbox with synthetic Companion data — no partner systems required.

{{ qsCode }}

{{ qsCur.response }}

Endpoints, organised by capability

Fetch is not a CRUD surface. Endpoints are grouped by the role they play in the exchange — contribute, qualify, interpret, deliver, trace, replay. Each one reinforces a canonical object, and every example object can be traced to its raw partner source.

{{ epPanelBody }}

The Fetch authentication model

Authentication in Fetch is not a token — it is a contract boundary. A key does not merely identify you; it scopes exactly which observations you may contribute, which intelligence you may consume, and which environment you operate in. Trust is enforced at the credential, not the request.

Sandbox and live keys are cryptographically distinct and never interchangeable. A sandbox key cannot read production continuity; a live key cannot be issued until your contract is certified.

curl https://api.fetch.companion.health/v1/account \
  -H "Authorization: Bearer sk_sandbox_3f9a..."

# the key resolves to its environment, scope, and contract
# → { "environment": "sandbox", "contract": "ctr_happy_pet_v2" }

Limits are enforced per key and returned on every response via X-Fetch-RateLimit-Remaining. Exceeding a limit returns 429 rate_limited with a Retry-After header — never a dropped observation.

An event system, not a callback

Production systems do not poll Fetch — they subscribe. When the exchange qualifies a signal or constructs an interpretation, it emits an event to every consumer whose contract admits it. Each event carries a fully traceable object, signed and delivered with explicit guarantees.

{{ whCur.payload }}

Fetch-Signature: t=1736006400,v1=4f8a9c...

# verify before trusting any payload
const signed = `${t}.${rawBody}`;
const expected = hmacSHA256(signed, endpoint_secret);
if (expected !== v1) reject(); // discard unsigned or stale events

Fetch is infrastructure. Reliability is a contract term, not a marketing claim. Figures below are sandbox-representative of the production exchange over a trailing 90-day window.

How a partner gets to live

A Fetch Contract is a canonical object, not a business process bolted on. It governs which observations a partner may contribute, which signals it may consume, and the certification it must pass before a live key is issued. This is the path from first conversation to first signal.

Aggregate of the five stages below, for a typical partner with structured telemetry. Each stage states its own duration, owner, and gate.

Run the exchange yourself

This is the exchange, live, on synthetic data. Contribute an observation, watch it qualify, retrieve the signal it produces, read the interpretation, and trace the whole chain to source. The qualification logic the docs describe runs in front of you — change the input and the outcome changes with it.

{{ f.body }}

Install, pin, and stay current

Official SDKs wrap the exchange in idiomatic clients. The API is versioned and stable — you pin a version, and breaking changes are announced with a fixed notice period and a long support window.

Go and Java clients are on the roadmap. Until then, the API is plain REST + JSON — any HTTP client works, and every endpoint in the catalogue shows a cURL example.

What changed, and when

Every documented capability of the exchange, in reverse order. Additive changes ship continuously; breaking changes are versioned and announced with notice.

{{ lifeView.title }}

{{ lifeView.lead }}

{{ lifeCur.state }}