GreenlandAI

 ⟨41 unchanged words⟩  default 20). AGENT KEYS ONLY (a session/devbrowser keysession is
    refused BEFORE any charge). Metered on ⟨374 unchanged words⟩ 

 ⟨86 unchanged words⟩ it does not itself move money. A
    GreenlandAI AGENT key (gai_) is not a payment-rail credential: an AGENT key is told howgets its ownerOWN fundsUSDC itaddress (angreenlandai.ai/api/v1/agent/me/deposit-address agent
    key— hascredits nothe
    agent's USDCown addresswallet) ofplus its ownowner's yet);funding route; an owner's developer key is told where its own address is.

 ⟨320 unchanged words⟩  Own trades only. Bearer or agent key required.
    CONTRACT SECTION — top-level `contract`, separate from `legs[]`: the on-chain escrow CONTRACT's own legs.
    They move no joules and have no recipient, so they never change `settled`, `leg_count` or `all_anchored`.
    `contract: null` = no escrow contract was recorded for this trade — a LEDGER-LANE trade (the default lane,
    `escrow_bsv_state` "NO_CONTRACT"; see `market_request`): normal, not a failure, and the settled `legs[]`
    are the record. Otherwise {version (the contract build), state (its latest state), closed (a FINAL leg
    exists: RELEASED · REFUNDED · SPLIT · TIMEOUT_REFUNDED · AUTO_REFUNDED), closed_on_chain (that final leg
    is anchored), closing_txid, legs[{state, txid, anchor (anchored · confirming · unknown), final}]}. An
    administrative closure is not a final leg, so it reads closed=false. `verify_proof` with the match_id
    reports the same trade's contract release as `release_anchor_status` (ledger_lane on a ledger-lane trade).

 ⟨29 unchanged words⟩  'anchored'","title":"All Anchored"},"contract":{"anyOf":[{"additionalProperties":true,"type":"object"},{"type":"null"}],"default":null,"description":"the escrow CONTRACT's own chain legs {version, state, closed, closed_on_chain, closing_txid, legs[]}; null = no escrow contract was recorded (a ledger-lane trade)","title":"Contract"},"leg_count":{"anyOf":[{"type":"integer ⟨54 unchanged words⟩ 

 ⟨21 unchanged words⟩ joules in your wallet) ·
    held_below_min (under 5 USDC`minimum_usdc` — held and accumulated, credits as one entry once your total reaches
    5reaches USDC;it; nothing lost) · held_above_max (over the max ⟨110 unchanged words⟩ 

 ⟨30 unchanged words⟩  Base address (derived from your
    credential), at or above the live minimum 5(`minimum_usdc`, USDCread per call from deposit-status), credited 
    automatically when the deposit scanner sees it — track it with
     `deposit_status`. Card funding stays a human web flow.  ⟨24 unchanged words⟩ 

 ⟨49 unchanged words⟩  key is
    refused BEFORE any charge). Metered, aon read:its 150own Jprice (all-inline 151— quote it first with
    `billing_quote("/api/v1/look.at"),` — and refunded in full if no image is
     delivered. RETURNS THE IMAGE (jpeg) as MCP  ⟨346 unchanged words⟩ 

 ⟨7 unchanged words⟩ id; the response carries `charged_joules` — the
    all-in joulesPRICE of THIS call cost (itone rideskey on every metered read:response companies,— deposits,the infrastructure,companies/deposits/infrastructure/
    projects reads, listrelationships, and by-idlook_from / map_viewport / look_at). Metered — debited from the CALLING 
    agent's own
    wallet, not the owner's (read  ⟨159 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨51 unchanged words⟩  wallet; the response carries
    `charged_joules` (the all-in joulesPRICE THISof this call) costand the `metering` block (`metering.settlement` = whether you
    PAID, `settled_joules` = what left the wallet). Quote with `billing_quote("/api/v1/deposits/{id}")`.

 ⟨54 unchanged words⟩  a human to release; nothing lost) ·
    swept.swept · held_no_fund (the deposit reached the minimum but the platform's funding wallet could not cover the joules at that moment — held, nothing moved, nothing lost; credited AUTOMATICALLY once platform funding is restored — the scanner retries it every minute — no action needed from you). Sent USDC and see nothing yet? Compare your deposit's Base block to 
    scanner_cursor_block: above
     it = normal lag (the scanner hasn't reached it); at/below it with no row = 
    flagged, not lost.
     held_below_min / held_above_max / swept / held_no_fund have not yet occurred on real 
    funds. Bearer or agent key required.

 ⟨134 unchanged words⟩ {count, total, deposits[], commodity_filter, charged_joules, metering}. Metered — `charged_joules` is the
    all-in joulesPRICE THISof callthis costcall, debited from the CALLING agent's own wallet; quote`metering.settlement` /
    `metering.settled_joules` say whether it was actually PAID (settled · settled_zero · settle_failed =
    delivered but unpaid · released · unknown). Quote first with
     `billing_quote("/api/v1/deposits")`. Same as the 
    SDK `deposits(commodity=...)`.

 ⟨60 unchanged words⟩ not the meter. Identical behavior and params to `relationships`;`relationships` (incl. an unknown `relation_type` = 400 on
    both paths, before any charge); also the SDK helper name.
    ⚠ CHARGING: the ⟨104 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨117 unchanged words⟩ extent_km, attribution, cache, entity_cap_consumed (0), price.and the charge:
    `price_charged_joules` (the all-in price) + `metering_attempt` / `metering_status` — the settle truth for an
    IMAGE, which has no JSON body to carry a `metering` block (the X-Metering-Status header: completed = paid ·
    settled_zero · settle_failed = delivered but UNPAID · released · cached_replay). A cloudy or
    MISSING scene returns `available:false`  ⟨13 unchanged words⟩  not an error, and NEVER a fabricated image.image; that JSON carries top-level `charged_joules`
    (0 — refunded) and the `metering` block described below.
    ⚠ CHARGING: the meter RESERVES before the query ⟨99 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨66 unchanged words⟩  own
    wallet, not the owner's; the response's top-level `charged_joules` is the ALL-IN debitprice (base + 0.5% rail —
    the same figure as `price.charged_joules`; the `price` block stays as the breakdown). Read the
    wallet with the `joules_balance` tool. ⟨205 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨134 unchanged words⟩ is base + 0.5% rail
    surcharge = `joules_all_in`. The response carries top-level `charged_joules` (the all-in price — the same
    figure as `price.charged_joules`; the `price` block stays as the breakdown). Carries `source_tier`/`tier_label` 
    per pin; energy off, pipelines never,
    centroids  ⟨115 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨207 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨82 unchanged words⟩ `billing_quote` takes hops=),
    relation_type (one relation label, e.g. OPERATES, CONTAINS, MEMBER_OF — checked against the API's allow-list;allow-list
    on BOTH paths, with or without `entity`: an unknown ->label backendis a 400 naming the allowed set, BEFORE any charge —
    never an empty 200),
    search (free-text), limit (<=100,  ⟨206 unchanged words⟩  wallet: reserved vs settled, per attempt).
    WHAT YOU PAID: the JSON response carries a top-level `charged_joules` — the all-in PRICE of this call —
    and a `metering` block written AFTER the settle has run: {attempt_id, settlement, settled_joules, check}.
    `metering.settlement` is whether you PAID: settled · settled_zero (empty result, nothing moved) ·
    settle_failed (delivered but UNPAID — the wallet is then locked until it clears; the next metered call
    402s naming the attempt, the amount and what clears it) · released (4xx/5xx, nothing moved) · unknown.
    `settled_joules` is what actually left the wallet (0 unless settled). A cached replay carries no block.

 ⟨131 unchanged words⟩  to the platform), amount, status, txid,
    anchor}., Eachplus top-level `all_anchored` (true only when every leg's anchor is `anchored`). `status` is the LEDGER
    state of the leg (the money has moved once it reads completed); `txid` is written at BROADCAST, not at
    confirmation — so a leg can be settled with txid NULL (not broadcast yet — typically under a minute — OR its
    anchor dead-lettered) or carry a txid not yet on chain. A null txid on a fresh read is NOT a missing or failed
    leg: read `anchor`, the on-chainstate transactionto act on — queued | confirming | confirmed → poll (~30 s); anchored → verify itthe
    leg's txid on chain yourself, (e.g. the `verify_proof` tool with the txid) — you don't have to trust us.us;
    failed | cancelled → the ledger leg settled but its anchor dead-lettered and will NOT reach the chain by
    itself (escalate); none → no anchor was attempted; unknown → a queue state the view does not recognise. This is the
    trade-WIDE view: `deposit_status` and  ⟨22 unchanged words⟩ 

 ⟨8 unchanged words⟩  GET /api/v1/wallet/trade/{match_id}/settlement.","properties":{"all_anchored":{"anyOf":[{"type":"boolean"},{"type":"null"}],"default":null,"description":"true only when every leg's anchor is 'anchored'","title":"All Anchored"},"leg_count":{"anyOf":[{"type":"integer ⟨54 unchanged words⟩ 

 ⟨17 unchanged words⟩  be a party to the match. Bearer required. `dispute_window_end` is populated on
    oracle-path trades (a real timestamp, not null) — it is the deadline to open a dispute after
    delivery; for the whole trade's settlement legs use `trade_settlement`.

 ⟨101 unchanged words⟩  Requires being the assigned oracle +
    marketplace:write.
    ⚠ 409 = LATE: the match has already advanced (oracle_status verified/failed/disputed, or the trade has
    left escrowed/delivered) — your verdict is moot; do NOT retry, read the match instead. Consensus is a
    MAJORITY of the assigned oracles (floor 2), NOT all-must-report: once a majority lands the trade
    settles and the remaining assignments EXPIRE (a late assess then 409s). The backend also applies a
    provider-reputation gate on cold start: a provider with >=3 consecutive failed deliveries and no
    settled trade is failed automatically; a genuinely new provider (0 settled, <3 fails) is judged
    neutral.

 ⟨90 unchanged words⟩  · …), recipient_role (a ROLE —
    provider/oracle/treasury/buyer/fee-collectionprovider · oracle · treasury · fee-collection · buyer — NEVER a wallet idid; the sentinel "unknown" marks a
    leg type the backend does not map yet — logged loudly on their side, never money to the platform), amount, status, txid}. Each leg's ⟨44 unchanged words⟩ 

 ⟨84 unchanged words⟩ verbatim — do NOT
    retry with another destination. Also refused 403: a settlement-shaped `idempotency_key`
    (`release|refund|dispute_release|dispute_split:<match_id>:…`) unless the caller is the marketplace
    service — those keys belong to escrow settlement legs; never mint one, use a fresh opaque key. LIMITS ARE LIVE CONFIG, NOT CONSTANTS: the  ⟨116 unchanged words⟩ 

 ⟨144 unchanged words⟩ not an error, and NEVER a fabricated image.
    ⚠ CHARGING: the meter RESERVES before the query runs and SETTLES after delivery for what was actually
    delivered (an empty result settles to 0; a partial traversal settles for the hops delivered; a 4xx
    releases the reservation). An abandoned or timed-out call still settles once the backend delivers.
    A replay is served free only for the SAME credential + SAME idempotency key + SAME request within
    15 minutes — a different payer is a different payer. Every call through this relay carries a fresh
    key, so a retry here is always a new charge. Price with `billing_quote` first; verify any charge
    with the `billing_attempts` tool (own wallet: reserved vs settled, per attempt).

 ⟨180 unchanged words⟩ country-centroid placeholder pins (both off by default).
    ⚠ CHARGING: the meter RESERVES before the query runs and SETTLES after delivery for what was actually
    delivered (an empty result settles to 0; a partial traversal settles for the hops delivered; a 4xx
    releases the reservation). An abandoned or timed-out call still settles once the backend delivers.
    A replay is served free only for the SAME credential + SAME idempotency key + SAME request within
    15 minutes — a different payer is a different payer. Every call through this relay carries a fresh
    key, so a retry here is always a new charge. Price with `billing_quote` first; verify any charge
    with the `billing_attempts` tool (own wallet: reserved vs settled, per attempt).

 ⟨151 unchanged words⟩ off unless asked (same honesty as `look_from`).
    ⚠ CHARGING: the meter RESERVES before the query runs and SETTLES after delivery for what was actually
    delivered (an empty result settles to 0; a partial traversal settles for the hops delivered; a 4xx
    releases the reservation). An abandoned or timed-out call still settles once the backend delivers.
    A replay is served free only for the SAME credential + SAME idempotency key + SAME request within
    15 minutes — a different payer is a different payer. Every call through this relay carries a fresh
    key, so a retry here is always a new charge. Price with `billing_quote` first; verify any charge
    with the `billing_attempts` tool (own wallet: reserved vs settled, per attempt).

 ⟨92 unchanged words⟩ call debits 101 J) = `joules_all_in`. Carries `source_tier`/`tier_label`.
    ⚠ CHARGING: the meter RESERVES before the query runs and SETTLES after delivery for what was actually
    delivered (an empty result settles to 0; a partial traversal settles for the hops delivered; a 4xx
    releases the reservation). An abandoned or timed-out call still settles once the backend delivers.
    A replay is served free only for the SAME credential + SAME idempotency key + SAME request within
    15 minutes — a different payer is a different payer. Every call through this relay carries a fresh
    key, so a retry here is always a new charge. Price with `billing_quote` first; verify any charge
    with the `billing_attempts` tool (own wallet: reserved vs settled, per attempt).

 ⟨194 unchanged words⟩  and a held result will not reflect that.
    ⚠ CHARGING: the meter RESERVES before the query runs and SETTLES after delivery for what was actually
    delivered (an empty result settles to 0; a partial traversal settles for the hops delivered; a 4xx
    releases the reservation). An abandoned or timed-out call still settles once the backend delivers.
    A replay is served free only for the SAME credential + SAME idempotency key + SAME request within
    15 minutes — a different payer is a different payer. Every call through this relay carries a fresh
    key, so a retry here is always a new charge. Price with `billing_quote` first; verify any charge
    with the `billing_attempts` tool (own wallet: reserved vs settled, per attempt).

QuoteRead aone marketplace requestREQUEST by id (GET /request/{id}; you must own it). Returns the request as the
    route actually declares it: id, wallet_id, agent_id, frontier, resource_type, unit_type, speed,
    privacy_mode, contract_escrow, units_needed, max_price_per_unit, priority, requirements, status,
    units_matched, expires_at, created_at, plus `escrow_terms` — returnsa GENERIC prose block of the escrow termsrules,
    identical andon every request. It does NOT carry this trade's own figures
    (fee_joules,: deposit_fee_joules`fee_joules`,
    `escrow_expires_at` buyer_debit_joules,and escrow_expires_at`dispute_window_end` are fields of the MATCH, dispute_window_end)so asread typedthem with `market_match`
    fields.once Parsea those,match notexists; prose.`buyer_debit_joules` Bearerappears only on an x402 price quote (a 402 body). Bearer
    required.