Integration Reference

API Reference

The Depth public API serves token execution snapshots with oracle provenance. All listed endpoints are unauthenticated. Beta access is open; contact us for integration support.

spec_version: 0.8base: api.depthoracle.io

Base URL

https://api.depthoracle.io

All paths below are relative to this base. No authentication is required. When rate limits are active, the API returns HTTP 429 Too Many Requests with Retry-After, X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers.

Endpoints

GET/health

Use this to confirm the public API is reachable. This is not a data or provenance endpoint; it only checks service liveness. Do not use the health status as a proxy for data freshness or oracle commitment state.

Example Request
curl -sS https://api.depthoracle.io/health

Response 200

FieldTypeDescription
statusstringHealth status indicator

What to look at

status"ok" when the service is running
GET/v1/public/tokens/{token_address}/latest

The primary integration endpoint. Returns the latest committed execution snapshot for a token, including the full pool array with per-pool evidence, oracle provenance, and computation disclosure. Start here unless you have a specific reason to use a lighter endpoint. /summary returns aggregated token-level stats without the pool array; /raw is the same shape as this endpoint but pre-processing.

Example Request
curl -sS https://api.depthoracle.io/v1/public/tokens/0x4200000000000000000000000000000000000006/latest

Path Parameters

NameTypeDescription
token_addressstringToken contract address (0x-prefixed)

Query Parameters

NameRequiredDescription
includenoAdditional data to include in the response

Response 200 — PublicTokenLatestResponse

FieldTypeDescription
token_addressstringToken contract address
as_of_tsstringISO 8601 timestamp of the snapshot
spec_version"0.8"Payload contract version; treat as a hard compatibility boundary
metaPublicMetaProvenance envelope: cache age, freshness, hash, oracle attestation
payloadPayloadV0_8Full evidence payload; contains token_context and pools[]

What to look at

spec_versionPayload contract version; pin to this and test forward compatibility explicitly
meta.freshness_statusfresh | stale | unknown; stale means the underlying evidence is aging
meta.oracle_tx_hashOn-chain commitment proof; null if not yet committed
payload.token_contextToken-level rollup: total eligible liquidity, pool counts, dominant share
payload.pools[].execution_policy .is_execution_eligibleWhether this pool passes all eligibility gates
payload.pools[].coverage .has_observation_coverageWhether bounded, recent execution evidence exists for this pool
payload.pools[].computationWhat was modeled, what was refused, and why; read before sizing
GET/v1/public/tokens/{token_address}/summary

Aggregated token-level liquidity posture without the full pool array. Use for monitoring dashboards or high-frequency polling where you need token-level eligibility state and do not need to iterate individual pools. Faster response than /latest; no per-pool detail.

Example Request
curl -sS https://api.depthoracle.io/v1/public/tokens/0x4200000000000000000000000000000000000006/summary

Path Parameters

NameTypeDescription
token_addressstringToken contract address (0x-prefixed)

Response 200 — PublicTokenSummaryResponse

FieldTypeDescription
token_addressstringToken contract address
as_of_tsstringISO 8601 snapshot timestamp
spec_version"0.8"Payload contract version
metaPublicMetaProvenance envelope
summary.coverageobjectPool discovery and observation coverage counts
summary.executionobjectEligible pool count and liquidity totals
summary.dominanceobjectDominant pool execution share (0–1)
summary.freshnessobjectSnapshot timestamp and data_age_seconds
summary.anomaly_flagsstring[]Detected anomaly codes, if any

What to look at

summary.execution .eligible_pool_countHow many pools currently pass all execution gates
summary.execution .eligible_liquidity_usdAggregated eligible liquidity in USD across those pools
summary.coverage .pools_with_coverageHow many pools have active observation evidence
summary.freshness .data_age_secondsAge of the underlying evidence; monitor for staleness
GET/v1/public/tokens/{token_address}/pools

Paginated list of all tracked pools for a token. Each item carries top-level eligibility, coverage, and TVL flags without the full evidence payload. Use this to enumerate the pool universe and filter by eligibility before fetching individual pool detail. Use cursor for pagination through large pool sets.

Example Request
curl -sS https://api.depthoracle.io/v1/public/tokens/0x4200000000000000000000000000000000000006/pools

Path Parameters

NameTypeDescription
token_addressstringToken contract address (0x-prefixed)

Query Parameters

NameRequiredDefaultDescription
limitno50Number of pools to return (min 1, max 200)
cursornoPagination cursor from a previous response's next_cursor
includenoAdditional data to include

Response 200 — PublicTokenPoolsResponse

FieldTypeDescription
token_addressstringToken contract address
as_of_tsstringISO 8601 snapshot timestamp
spec_version"0.8"Payload contract version
metaPublicMetaProvenance envelope
poolsPublicPoolListItem[]Array of pool list items
next_cursorstring | nullCursor for the next page; null when exhausted
limitintegerLimit used in the request

What to look at

pools[].is_execution_eligibleQuick filter for pools that pass all execution gates
pools[].has_observation_coverageWhether the pool has active bounded evidence
pools[].tvl_usdPool size context; null if not yet computed, do not impute
next_cursornull means you have reached the last page
GET/v1/public/tokens/{token_address}/pools/{pool_address}

Full evidence snapshot for one pool in the context of a token. Returns the same pool object shape found in /latest but scoped to a single pool, including execution structure, detailed computation disclosure, and boundary evidence. Use this for pool-level inspection before sizing an execution or to understand why a pool is or is not eligible.

Example Request
curl -sS https://api.depthoracle.io/v1/public/tokens/0x4200000000000000000000000000000000000006/pools/0xb2cc224c1c9fee385f8ad6a55b4d94e92359dc59

Path Parameters

NameTypeDescription
token_addressstringToken contract address (0x-prefixed)
pool_addressstringPool contract address (0x-prefixed)

Response 200 — PublicTokenPoolDetailResponse

FieldTypeDescription
token_addressstringToken contract address
as_of_tsstringISO 8601 snapshot timestamp
spec_version"0.8"Payload contract version
metaPublicMetaProvenance envelope
poolPoolSnapshotFull pool evidence snapshot

What to look at

pool.execution_policy .is_execution_eligibleOverall eligibility result for this pool
pool.execution_policy .ineligibility_reasonsReason codes when not eligible; start debugging here
pool.coverage .has_observation_coverageWhether bounded, recent execution evidence exists
pool.liquidity_state .effective_depth_usdObservable execution depth in USD; null if not computed
pool.execution_structurePool-specific execution parameters and price boundaries
pool.computationWhat was modeled, what was refused, and why; not_modeled ≠ ineligible
GET/v1/public/tokens/{token_address}/raw

Raw unprocessed evidence payload. Same response shape as /latest; the payload field is the canonical artifact before any intermediate processing layer. Use for audit trails, archival, or integrity verification. Not intended for real-time integration; prefer /latest.

Example Request
curl -sS https://api.depthoracle.io/v1/public/tokens/0x4200000000000000000000000000000000000006/raw

Path Parameters

NameTypeDescription
token_addressstringToken contract address (0x-prefixed)

Response 200

FieldTypeDescription
token_addressstringToken contract address
as_of_tsstringISO 8601 snapshot timestamp
spec_version"0.8"Payload contract version
metaPublicMetaProvenance envelope
payloadPayloadV0_8Unprocessed evidence payload

What to look at

meta.payload_hashHash of the canonical artifact; use to verify payload integrity
meta.hash_algAlgorithm used to produce the hash
meta.oracle_tx_hashOn-chain commitment proof tying this artifact to a block

Key Schemas

PublicMeta

Provenance envelope present on every response. Carry these fields in integration logs for post-mortems and audit trails.

FieldTypeDescription
computed_atstring | nullWhen the evidence was computed
policy_versionstring | nullExecution eligibility policy applied
cache_age_secondsintegerAge of this cached response in seconds
data_age_secondsinteger | nullAge of the underlying data in seconds
expected_cadence_secondsintegerExpected update interval in seconds
freshness_statusstring | nullfresh | stale | unknown
payload_hashstring | nullHash of the canonical payload
hash_algstring | nullHashing algorithm used
oracle_tx_hashstring | nullTransaction hash of the oracle commitment
oracle_block_numberinteger | nullBlock number of the oracle submission
oracle_chain_idinteger | nullChain ID of the oracle submission
committed_atstring | nullISO 8601 timestamp of on-chain commitment
artifact_urlstring | nullURL to the published evidence artifact

oracle_chain_id identifies the proof network where the commitment was anchored. 8453 = canonical live commitments on Base mainnet. 84532 = historical beta commitments on Base Sepolia. In both cases the underlying payload domain is Base mainnet liquidity and execution context.

PayloadV0_8 — token_context

Token-level rollup derived strictly from pool data. Useful for routing or eligibility gates without iterating individual pools.

FieldTypeDescription
total_observable_liquidity_usdnumber | nullSum of TVL across all pools with computed TVL
total_execution_eligible_liquidity_usdnumber | nullSum of TVL across execution-eligible pools
dominant_execution_sharenumber | nullLargest single-pool share of eligible TVL (0–1)
pools_with_execution_coverageintegerPools with active observation coverage
pools_discoveredintegerTotal pools discovered for this token
PoolSnapshot — key fields

Individual pool evidence object. Found in payload.pools[] from /latest and as pool from the pool detail endpoint. Interpret outputs in conjunction with spec_version, meta.policy_version, and meta.oracle_tx_hash. A computation field showing not_modeled or not_computed does not automatically make a pool ineligible; read the reason before acting.

FieldTypeDescription
pool_addressstringPool contract address
pool_typestringv2 | v3 | aerodrome_concentrated | aerodrome_volatile | aerodrome_stable
paired_tokenstring | nullPaired token contract address
execution_policy.is_execution_eligiblebooleanWhether this pool passes all eligibility gates
execution_policy.policy_versionstringPolicy version applied to this pool
execution_policy.ineligibility_reasonsstring[]Reason codes when not eligible
coverage.has_observation_coveragebooleanWhether bounded, recent execution evidence exists
coverage.observation_freshnessstring | nullfresh | stale | unknown
coverage.observation_window_hoursnumber | nullLength of the observation window in hours
liquidity_state.effective_depth_usdnumber | nullObservable execution depth in USD
liquidity_state.volume_window_usdnumber | nullVolume over the observation window
liquidity_state.volume_rationumber | nullvolume_window / tvl, activity relative to size
tvl.tvl_usdnumber | nullPool TVL in USD; null if not computed
tvl.tvl_methodstring | nullValuation method used
computation.liquidity_state.computedbooleanWhether liquidity_state was computed
computation.liquidity_state.reasonstring | nullWhy it was not computed, if applicable
computation.tvl.computedbooleanWhether TVL was computed
computation.tvl.reasonstring | nullWhy TVL was not computed, if applicable
PublicPoolListItem

Lightweight pool item returned from the /pools list endpoint. All fields may be null if not yet computed.

FieldTypeDescription
pool_addressstring | nullPool contract address
pool_typestring | nullPool type
paired_tokenstring | nullPaired token address
tvl_usdnumber | nullTotal value locked in USD
observable_liquidity_sharenumber | nullShare of token observable liquidity in this pool (0–1)
has_observation_coverageboolean | nullWhether the pool is actively observed
observation_freshnessstring | nullfresh | stale | unknown
is_structurally_supportedboolean | nullWhether the pool structure is decodable
liquidity_context_eligibleboolean | nullEligible for liquidity context
is_execution_eligibleboolean | nullEligible for execution

Core Principle: Fail Closed

Depth is designed for integrations that fail closed under uncertainty. If a pool lacks observation coverage, treat its liquidity metrics as unknown. If execution eligibility is false, do not treat that pool as an execution surface. If TVL is null, do not impute it.

The payloads are structured to make these conditions explicit rather than hiding them behind defaults. An unknown is returned as null with a reason, not as zero or an estimate.

Reading the Payload

The API payload is a qualification layer, not an execution instruction. These notes describe how to interpret the key signals.

Inspect eligibility directly. execution_policy.is_execution_eligible is the oracle's deterministic eligibility gate for a pool. A pool with is_execution_eligible = false has failed at least one policy condition; inspect ineligibility_reasons for the specific cause.

Read coverage as evidence scope. coverage.has_observation_coverage tells you whether bounded, recent execution evidence exists for a pool. A pool without coverage has no bounded evidence window; its liquidity metrics may be absent or stale.

Read computation as a disclosure, not a gate. computation.liquidity_state.computed = false means that section was not computed; it does not make the pool ineligible. A pool can be structurally supported, observed, and execution-eligible while liquidity_state remains unmodeled. Inspect computation.liquidity_state.reason to understand why.

Treat null as explicit missingness. Null and uncomputed values are returned as null with a reason field, not as zero or an estimate. Do not impute them.

Use state changes as monitoring signals. is_execution_eligible flipping false on a primary pool, pools_with_execution_coverage dropping to 0, or computation.tvl.computed changing true → false are factual state changes worth alerting on. These are disclosures, not predictions.

Beta Posture

Depth is in beta. Pool discovery is best-effort; the pools array in a payload is not guaranteed to enumerate every pool on Base for a given token. Uptime guarantees are intentionally absent. Coverage is intentionally partial.

spec_version refers to the payload contract version; it is not the same thing as the REST API version. Treat it as a hard compatibility boundary. Treat unknown response fields as non-fatal. If you integrate during beta, pin to spec_version: "0.8" and test forward compatibility explicitly before adopting future versions.