MCP tools reference

The Amnetic marketplace exposes up to 23 MCP tools over the Model Context Protocol. This is the single authoritative list of what each tool takes and returns; the per-client connection config lives on Connect your agent, and the get-connected-fast path on Connect your MCP client.

The 13 core tools are always registered — none is behind a feature flag. Four further groups register only behind a feature flag; where the flag is off they are simply absent from tools/list and calling them is a not-found (404-by-absence), never a disabled stub:

• the five buyer-posting request tools (create_request_draft, list_my_requests, respond_request, list_open_requests, and the seller-write submit_request_candidate) register only where BUYER_POSTING_ENABLED is on;
• the two seller license-offer tools (set_license_offers, get_license_offers) register only where LICENSE_TERMS_ENABLED is on;
• the two seller slice-policy tools (set_slice_policy, get_slice_policy) register only where SLICE_ON_DEMAND_ENABLED is on.
• the buyer report tool registers only where CONSIGN_ENFORCER_ENABLED is on.

With all feature flags enabled there are 23: eleven are buyer tools, twelve are seller tools; the same account can do both.

Authentication is transport-level

You authenticate once, on the transport — your amn_… API key travels as Authorization: Bearer amn_… when the connection is established (or, for the claude.ai browser connector, as a Cognito OAuth login). The key is never a tool argument — it stays out of your agent's model context and out of tool-call transcripts. The server refuses to start without an authenticator; there is no open/anonymous mode. See Authentication.

Endpoints

The MCP server lives on the same host, port (443), and TLS certificate as the REST API. It speaks two transports so every client can use streamable HTTP, with SSE retained for legacy clients:

Transport	Path	Clients
Streamable HTTP (recommended)	https://market.amnetic.ai/mcp	Claude Code, Cursor, the claude.ai browser connector, ChatGPT, amnetic solution CLI, and generic MCP clients
HTTP + SSE (legacy fallback)	https://market.amnetic.ai/sse	Older SDK-only clients that do not yet speak streamable HTTP

Buyer tools (11)

enter_market

Hand your working context into the wall and get a buy recommendation. Free and read-only — it buys nothing.

Param	Required	Meaning
messages	yes	Your working conversation as a standard chat stream (roles system | user | assistant). Must include at least one user message.
llm_model	no	The LLM the inner agent runs on. Must exactly match a supported Claude model ID such as claude-opus-4-6 (the default), claude-sonnet-4-6, claude-opus-4-7, or claude-haiku-4-5.
image_id	no	The inner-agent image — a human-readable slug (e.g. code_solutions) or the raw sha256 from list_images. Defaults to the platform default.
required_rights	no	Buyer-declared minimum license rights, as a closed enum-only object. Request any subset of use, redistribution_scope, derived_display, training, training_serve, training_weights, term, and attribution; omitted dimensions mean “don't care.” Omitted, null, and {} all leave rights-fit inactive. This field is absent from tools/list while the counsel-gated licensing capability is dark.

The request vocabulary is closed: use is non_commercial|commercial; redistribution_scope is individual|entity|entity_affiliates; derived_display is none|public; training is none|internal; training_serve and training_weights are independently none|allowed; term is 12|24|36|perpetual; and attribution is required|not_required. exclusivity is not requestable. Unknown properties or values are rejected before a market session starts.

Returns decision ("buy" or "no_match"), recommended_listings[] (each with public catalog metadata: listing_id, document_type, title, description, category, price_cents, currency, optional seller_name, data_format, data_size_bytes, tags, status, created_at, updated_at, and an optional trust band). In non-production environments where the dark LICENSE_TERMS_ENABLED flag is on, each recommendation also has a provisional pre-purchase license quote block with schema_version, a fully materialized standard tier, and offers[]; every tier carries its price and settlement-binding token, and composed tiers also carry offer_id, offer_key, and currency. This metadata is not operative license text, a grant, or acceptance, and remains unavailable in production pending counsel ratification and the separate exact-text read surface. When a non-empty required_rights object is accepted, every recommendation additionally carries platform-computed rights_fit: band is fit, partial, no_fit, or unknown, and best_offer appears only for fit. Its {offer_id, offer_key, terms, price_cents, currency, token} is the normalized selector for the selected visible quote: composed fields are copied directly; the standard tier combines its visible terms/price/token with the listing currency and uses offer_id: null, offer_key: "standard". This is mechanical buyer-parameterized comparison, not a legal interpretation, permission, warranty, reservation, or grant. That exact-text read surface is not part of this phase, so do not treat the enum metadata as the operative terms or purchase from it alone. offers is [] when no composed tier is live. The response also includes recommended_total_cents and, on no-match, optional gap_report.unmet[] class values. Gap classes are closed vocabulary (coverage, freshness, granularity, format, price, trust, rights) and carry no notes or prose. No raw seller id, document body, data_ref, data_dictionary, inner-agent reason, confidence score, or other free-form inner-agent prose crosses the wall.

While evaluating candidates inside the market, the forgetful buyer agent's get_listing response includes a top-level license_offers array. The virtual standard offer is always first (offer_id: null), followed by active composed tiers; each entry carries offer_key, the fully materialized enum-only terms, price_cents, listing currency, and a settlement-binding token. Under the same dark licensing flag, the platform attaches that quotable ladder to the outer recommendation after the wall returns only listing ids. The data is read from current platform listing/offer rows — never authored by the inner agent. After reviewing the operative terms through an available exact-text surface, echo a composed tier's offer_id and optional token into an explicit purchase call, or echo the standard tier's token as expect_token; the recommendation itself is read-only and neither grants rights nor records acceptance.

With required_rights omitted, null, or {}, recommended_total_cents retains its historical meaning: the sum of the recommendations' top-level standard price_cents (and an all-zero total may remain omitted). With a non-empty requirement, it is instead the sum of each fit row's current best_offer.price_cents; partial/no-fit/unknown rows contribute zero, and the field is emitted explicitly even when the active sum is 0. Either total is advisory snapshot arithmetic, not a checkout amount or settlement promise.

To act on a fit, review the operative exact text, then echo rights_fit.best_offer.offer_id (omit/null for standard) and rights_fit.best_offer.token as expect_token into purchase. Purchase re-resolves current state; only its minted grant is license evidence. If an asynchronous card quote drifts after payment, fulfillment may finish funded_only: the payment remains spendable, nonwithdrawable wallet credit and no license grant is minted.

A seller account's own listings are excluded from that same account's enter_market recommendations and in-wall listing reads. Settlement also refuses self-purchase, so this filter is defense in depth and not the money-path guard.

Daily enter_market session quota is consumed only when the final response is decision: "buy" and recommended_listings contains at least one listing. no_match, rejected requests, setup failures, timeouts, and platform faults do not consume the daily session quota, although concurrency limits still apply while a session is running.

Tool errors are sanitized. When available, branch on structured error_code instead of parsing text. Public codes include auth_failed, invalid_request, unsupported_model, unknown_image, insufficient_credit, no_candidates, balance_unavailable, rate_limited, buyer_context_invalid, agent_artifact_invalid, sandbox_unavailable, budget_exhausted, buyer_cancelled, platform_terminated, and platform_error. Error responses never include seller body content, inner-agent prose, raw stream details, stack traces, bearer tokens, presigned URLs, or other platform internals. Some errors include a debug_id you can share with support.

The examination-ceiling N, suggestion-budget B, and session timeout are platform-set defaults, not parameters of this tool. Tuning them is an advanced REST/SDK concern (see the API reference).

purchase

Buy listings. The debit is atomic (all-or-nothing). A successful response confirms ownership and returns listing metadata; retrieve bytes with ownership_download.

By default the MCP tool uses wallet credit and can buy a bundle atomically. It also accepts funding_mode: "card_shortfall" or "card_full" for a single listing; card modes usually return a hosted Stripe checkout_url and settle asynchronously after payment. card_shortfall completes synchronously on the wallet rail if current wallet balance fully covers the item. Card modes accept the same offer-aware selectors as wallet (offer_id, expect_token, renew_of_grant_id), so a card-funded buyer can elect a composed/priced offer or bounded-term renewal.

Param	Required	Meaning
items	one of items / listing_ids	Offer-aware purchase items: {listing_id, offer_id?, expect_token?, renew_of_grant_id?}. Use this for composed license tiers, quote-token assertions, or renewals.
listing_ids	one of items / listing_ids	Legacy listing UUIDs to buy. Each id is equivalent to {listing_id}. Send exactly one of items or listing_ids; sending both or neither is rejected.
funding_mode	no	wallet (default), card_shortfall, or card_full. Card modes require exactly one item/listing and usually return checkout metadata instead of immediate ownership.

Returns purchases[] (each with listing_id, seller_id, title, price_cents, data_format, data_size_bytes, outcome, offer_id, offer_key, terms_hash, and grant_id), total_cents, and balance_cents_after for wallet purchases. Card-mode responses include payment_method, funding_mode, status, checkout_url, session_id, amount_cents, funded_cents, and wallet_applied_cents (the wallet amount planned at checkout creation, rechecked at settlement). outcome is purchased or already_licensed; skipped items are returned instead of silently omitted. If the balance can't cover a wallet order, nothing is purchased and nothing is debited. Offer-level refusals return structured error_code, listing_id, and detail fields: offer_unavailable, price_changed, or renewal_invalid. offer_unavailable.detail.live_offers includes replacement offers with terms, terms schema version, DLS version, price, and token. Arbitrary uploaded-file listings must have a clean malware scan before purchase; non-clean files are reported as unavailable and no debit occurs.

ownership_list

No arguments. Lists every listing your account already owns (with title, description, the price you paid, and when you acquired it).

Where LICENSE_TERMS_ENABLED is on (dark until the licensing terms are counsel-ratified), each owned listing also carries a license block recording the license evidence you hold:

• { "newest": {…grant…}, "grants": [ …newest-first history… ] } for a listing you hold a recorded grant on. Each grant view carries grant_id, offer_key, terms, terms_schema_version, dls_version, granted_at, and — for grants governed by the ToS draft — instrument_status: "pre_ratification". The grant view is token free (proof of what you hold, never a handle to buy again).
• { "implied": true } for a listing you own with no recorded grant — the implied standard-license display convention (no grant row is synthesized).

The block is omitted entirely where the flag is off, so the wire is unchanged on the dark path.

ownership_download

Param	Required	Meaning
listing_id	yes	A listing you own.

Returns a short-lived (5-minute) presigned GET URL, plus data_format and data_size_bytes. For text/plain payloads up to 256 KiB, the response also includes body inline so MCP clients that cannot fetch arbitrary URLs still have a one-call byte path. Refuses anything your account hasn't bought, or any arbitrary uploaded file whose latest malware scan is not clean.

This tool deliberately has no format argument and returns the listing's canonical owned artifact. Manifest-backed slice XLSX export is REST-only via GET /api/v1/ownership/{listingId}/download?format=xlsx.

balance

No arguments. Returns your read-only credit balance in cents (e.g. { "balance_cents": 4200, "currency": "USD" }). There is no MCP top-up — fund your account in the portal.

list_images

No arguments. Lists the inner-agent images selectable via enter_market's image_id — each with an image_id, slug, name, description, and default: true for the one used when you omit image_id.

purchase_status

Param	Required	Meaning
purchase_id	yes	The UUID of one of your own purchase transactions.

Buyer-scoped read. Returns listing_id, status, amount_cents, currency, created_at, and completed_at. A transaction owned by another buyer is reported not-found (no 403, so you can't enumerate other buyers' IDs).

Where LICENSE_TERMS_ENABLED is on (dark until the licensing terms are counsel-ratified), the response also carries offer_key and terms_hash — the licensing tier you purchased and the hash of its composed terms — for a transaction that minted a license grant. Both are omitted where the flag is off.

report

Report a questionable record from a licensed Consign delivery without receiving a validity verdict or correction. Available only where CONSIGN_ENFORCER_ENABLED is on.

Param	Required for admission	Meaning
record_ref	yes	The exact AMN1-… support handle carried by the delivered artifact. The platform resolves it only through your authenticated account's delivery ledger.
record_key	yes	The opaque key of the record being reported.
where_encountered	no	Where you encountered the record, such as an exported customer file. This confession field is encrypted before durable storage.

The tool deliberately advertises a permissive arguments-object schema: missing, unknown, and wrong-typed values all reach the no-verdict handler. Every syntactically valid authenticated report call returns the same non-error result:

{ "status": "Logged. Under review with the data provider." }

That response does not confirm that the RecordRef, record key, delivery, or account relationship exists, and it is not proof that a report row committed. Account, delivery, license, and listing IDs are never accepted as tool arguments; they are derived server-side from transport authentication and the owner-scoped delivery ledger. RecordRefs are high-entropy, unguessable support handles in addition to being owner-scoped. The invariant covers the MCP result bytes and non-error status, not processing-time distributions: an admissible report may synchronously perform KMS encryption and a durable database commit, so Report does not claim timing secrecy. Malformed JSON-RPC, a different tool name, non-object arguments, or a transport body over the 1 MiB listener cap is rejected before the Report callback and remains outside the Report contract.

create_request_draft

Draft a buyer request — a public ask for information sellers can compete to fill. Available only where BUYER_POSTING_ENABLED is on. Creating a draft moves no money and posts nothing; the escrow bounty is reserved later, at sign-off, which is a portal-only human approval (see the gaps below).

Param	Required	Meaning
title	yes	Public one-line title of the request.
body	yes	Public description of the data/analysis you need.
bounty_micro_usd	yes	Escrow bounty in micro-USD (1 USD = 1,000,000 micro; e.g. 250000000 = $250). Must be positive. Reserved at sign-off, not on draft creation.
expires_at	yes	RFC-3339 timestamp; must be in the future.
category	no	Free-form category label.
tags	no	JSON array of discovery tags (e.g. ["finance","weekly"]).
hints	no	JSON object of structured hints about the shape of data you want.
attribution	no	named (default) or pseudonymous.
acl_mode	no	open (default) or allow (only the named access groups may see it).
acl_group_ids	no	Access-group IDs the request is visible to; required when acl_mode is allow (must be groups you own).

Returns the new request_id, state ("draft"), bounty_micro_usd, expires_at, attribution, acl_mode, and created_at.

list_my_requests

List your own requests and their current state. Available only where BUYER_POSTING_ENABLED is on.

Param	Required	Meaning
limit	no	Max requests to return (default 50).
offset	no	Requests to skip, for pagination (default 0).

Returns your requests — each with request_id, title, state, category, bounty_micro_usd, expires_at, attribution, signed_off_at (when signed off), and created_at.

respond_request

Act on a candidate that has passed evaluation on one of your own requests. Available only where BUYER_POSTING_ENABLED is on.

Param	Required	Meaning
request_id	yes	One of your own requests (from list_my_requests).
candidate_id	for confirm / decline	The candidate to act on — one that has passed evaluation on that request.
quote_id	for commit	The seller's quote to commit to.
action	yes	confirm to settle the fill, decline to pass on the candidate, or commit to accept a seller's above-bounty quote.

action=confirm settles the fill. A normal pass atomically releases your escrow bounty and buys the candidate's listing at the price captured when the seller submitted it — never a later, higher price — and closes the request. If the seller changed the listing price (or the listing is no longer available), the confirm is rejected and the candidate is voided; if the captured price is above your bounty, you must have enough spendable credit to cover the difference (top up and retry otherwise). action=decline passes on a normal candidate and keeps the request open for others — no money moves. A normal passed candidate remains confirmable for 72 hours from the platform-recorded pass time. At the exact deadline it lapses; a late confirm cannot charge, and a late decline records and returns that same lapsed outcome.

action=commit accepts a seller's quote — a bespoke, above-bounty price the seller offered (pass quote_id instead of candidate_id). It earmarks the top-up (the amount above your bounty) in escrow and reserves the seller's exclusive fill window so no one else can fill the request while they produce the work. It settles nothing yet — the purchase happens automatically at the quoted amount when the seller delivers. You must have enough spendable credit to cover the top-up; a quote at or under your bounty is rejected. Committing moves no request state (it stays open). If the seller never delivers, the commitment lapses when the window elapses and the top-up is released back to your bounty. If the seller's pass was durably recorded inside the commitment window (including either exact boundary), the automatic fill remains recoverable after the wall-clock window—even after a platform restart. That qualifying pass has earned settlement at the quoted amount: it cannot be declined or lapsed, and an explicit confirm routes through the same quote-settlement path. Only a commitment with no such earned pass lapses. Quote lapse releases only the quote top-up; the base bounty stays reserved until the request fills or finally expires.

Returns the request_state (e.g. filled after a confirm, open after a commit), the resulting candidate_state (confirmed / declined / lapsed) or quote_state (committed), and — on a settled confirm — the fill_transaction_id. A request, candidate, or quote that is not yours reads as an opaque "request not found".

The unattended fill (the automatic purchase when a committed seller delivers) and the lapse of an expired commitment are platform/worker transitions with no tool or REST route.

At the request deadline, a request with no evaluation or committed quote in flight becomes expired and releases its base bounty. A request with in-flight work becomes closing: new responses stop, existing work may settle, and the base bounty is released only if the final in-flight item ends without a fill.

Seller tools (12)

Seller identity always comes from the authenticated session — never a parameter.

create_listing

List a document for sale (text/markdown body only).

Param	Required	Meaning
title	yes	Public catalog title (≤200 chars).
body	yes	The full document content for sale (≤200000 bytes). Never shown pre-purchase.
price_cents	yes	Price in whole US cents. Open-market listings must be from 1 cent through $1,000,000.
description	no	Public catalog description (defaults to the title).
currency	no	3-letter ISO-4217 code (defaults to usd).
category	no	Free-form category label (≤64 chars).
document_type	no	Free-form discriminator (the server does not branch on it).
tags	no	Free-form discovery tags.
purchase_acl_mode	no	open (default) | allow | deny. A restricted listing may be priced at $0.
purchase_acl_groups	no	Named access-group IDs you own; used by allow/deny.
license_offers	no	Compose priced licensing tiers on the new listing in the same call — an object { offers: [...], accept_licensing_terms } with the same entries as set_license_offers. Available only where LICENSE_TERMS_ENABLED is on; supplying it where licensing is off is rejected (the block is never silently dropped). See Licensing.

Returns the new listing_id, status, and created_at. Document body only — there is no file or CSV/XLSX/parquet dataset upload path here (see the honest gaps below).

update_listing

Param	Required	Meaning
listing_id	yes	One of your own listings.
title / description / category / price_cents / tags / status	no	The fields you pass are updated (status is active or inactive).

Platform-created slice children are immutable marketplace artifacts. Attempting to edit one returns platform_slice_frozen; deactivate an unsold child through the slice lifecycle instead of changing its listing fields directly.

list_my_listings

No required arguments (optional limit / offset for pagination). Lists your own listings.

set_listing_acl

Param	Required	Meaning
listing_id	yes	One of your own listings.
mode	yes	open | allow | deny.
group_ids	no	Named access-group IDs you own; ignored when mode is open.

ACL replacement is also refused with platform_slice_frozen for a platform-created slice child.

get_listing_acl

Param	Required	Meaning
listing_id	yes	One of your own listings.

Returns the listing's mode and group_ids.

set_license_offers

Compose the priced licensing tiers on one of your own listings, alongside the listing's standard (default) terms. Available only where LICENSE_TERMS_ENABLED is on. Pass the full desired live offer set — replace-set semantics, not a patch: unchanged entries keep their ids, repriced or recomposed entries are re-versioned, dropped entries are retired, and an empty offers list retires all. See Licensing for the dimension vocabulary and offer_key grammar.

Param	Required	Meaning
listing_id	yes	One of your own listings whose offer ladder to replace.
offers	yes	The full desired live offer set. Each entry is { offer_key, terms, price_cents }: offer_key is a short stable tier slug (^[a-z0-9][a-z0-9_-]{0,31}$; standard/default are reserved), terms is a { dimension: option } map overlaid on the platform defaults (omitted dimensions take their default), and price_cents is the tier price in whole US cents. An empty list retires all offers.
accept_licensing_terms	no	Set true to accept the current licensing terms (the version is stamped server-side — you never supply it) so offers can be composed. Required once per account before composing; idempotent once accepted; ignored when offers is empty.

Before composing any offers your account must accept the current licensing terms. If it has not — and you did not pass accept_licensing_terms — the call is refused with a non-opaque message naming the version to accept and linking the instrument (licensing_terms_acceptance_required). Returns the resulting live offers[] (each with offer_id, offer_key, terms, terms_schema_version, dls_version, price_cents, currency, token, and status) plus any non-fatal coherence warnings[] (e.g. a broader tier priced at or below a narrower one). A listing you do not own — or one that does not exist — reads as an opaque "listing not found or not yours" (no cross-seller inventory oracle).

Offer replacement is refused with platform_slice_frozen for a platform-created slice child; its price and legal/economic envelope were fixed at materialization.

get_license_offers

Read the priced licensing tiers on one of your own listings. Available only where LICENSE_TERMS_ENABLED is on. Read-only; scoped to your authenticated seller account.

Param	Required	Meaning
listing_id	yes	One of your own listings whose offers to read.
include_retired	no	When true, also returns retired (superseded) offer rows; the default is the live set only.

Returns offers[] in the same shape set_license_offers returns (ids, terms, versions, price, token, status). A listing you do not own or that does not exist reads as the same opaque "listing not found or not yours".

set_slice_policy

Configure slice-on-demand for one of your own parent listings — the standing authorization and pricing envelope for seller-authored segments and buyer row-match requests. Available only where SLICE_ON_DEMAND_ENABLED is on. For the end-to-end portal workflow, see Selling slices.

You must accept the Slice Authorization rider first. Rider acceptance is a deliberate human act done in the seller portal / REST — it cannot be done through this tool (there is no rider-accept MCP tool). If you have not accepted the current rider, this call writes nothing and returns rider_acceptance_required: true with the current rider_version and rider_url to accept it.

Platform-created slice children cannot themselves become slice parents. The tool returns platform_slice_frozen if called for one.

Param	Required	Meaning
listing_id	yes	One of your own parent listings.
enabled	no	Whether slicing is enabled for this listing.
kinds	yes	Buyer-request allow-list: [] or ["row_match"]. An empty list still permits seller-authored segments but advertises no buyer-initiated request kind.
key_columns	when row_match	1–3 parent columns matched against buyer keys.
per_row_cents	when enabled	Price per matched row in US cents. Fractional (sub-cent) values are allowed, e.g. 0.5 for half a cent or 5 for five cents. Must be > 0. Stored at a resolution of 1/10,000 of a cent (nearest micro-USD, half away from zero); quotes use the rounded stored rate. It is the fallback when a seller-authored slice omits an explicit price.
min_price_cents	yes	Per-slice price floor, in whole US cents. Must be ≥ 100 (a mandatory $1.00 floor).
max_price_cents	no	Optional per-slice ceiling; when set must be > 0 and ≥ min_price_cents.
max_rows_per_slice / max_queries_per_job / max_jobs_per_buyer_per_day	no	Enforced per-job and buyer-account + parent rolling-24-hour bounds. Values must be positive when supplied; omitted query/job values default to 500 / 3.
max_cumulative_rows_per_buyer	no	Reserved policy value: accepted and stored, but not enforced in this beta. Cluster-wide, cross-listing, and cumulative-row metering are deferred.
disclosure_mode	no	aggregate_only (default) | per_query.
review_mode	no	auto (default) | review (hold row_match slices for your review).
watermark_mode	no	manifest_only (default).

On success returns the stored policy (ids/enums/scalars only — never any row data) plus warnings: non-blocking cannibalization notices you should see but that do not stop the write — for example, per-row pricing that lets a buyer reconstruct the whole dataset below the parent price. A floor below $1.00, a missing or non-positive per_row_cents on an enabled policy, an unknown key column, a max below the floor, a non-positive supplied cap, or an invalid enum are errors that refuse the write.

get_slice_policy

Param	Required	Meaning
listing_id	yes	One of your own parent listings.

Read-only. Available only where SLICE_ON_DEMAND_ENABLED is on. Returns the current policy's enabled state, buyer-request kinds, key_columns, pricing, all usage caps, and the disclosure/review/watermark modes. A listing you do not own — or one with no policy configured — reads as an opaque not found (no confirm/deny). See Selling slices for how this policy feeds the segment, activity, and review views.

seller_stats

No arguments. Returns sales count, gross revenue, marketplace fees, net earnings, balance, and withdrawable balance, plus a per-listing breakdown. It reads the withdrawable balance — it cannot initiate a payout.

Where LICENSE_TERMS_ENABLED is on, each listing also has an offer_breakdown array ordered by offer_key:

{ "offer_key": "internal-training", "sales_count": 3,
  "gross_revenue_cents": 750000 }

These are completed, grant-backed sales at the immutable amount charged for each transaction. Renewals and paid upgrades count as new sales; retries and funded-only checkout outcomes do not. Retired and re-versioned offer ids with the same key roll into the same commercial tier. An enabled listing with no grant-backed sales returns offer_breakdown: []. When licensing is off, the field is absent from both tools/list and tool responses (the dark schema is unchanged).

list_open_requests

Search the request board — open, unexpired buyer requests your account is eligible to see (the same ACL-filtered, open-only projection as the seller Request Board portal page). Available only where BUYER_POSTING_ENABLED is on.

Param	Required	Meaning
query	no	Free-text search over open requests.
category	no	Exact category filter.
min_bounty_micro_usd	no	Minimum bounty, in micro-USD (int64).
mode	no	text | vector | hybrid (default hybrid).
limit	no	Max results (default 20, capped at 100).

Returns the ACL-filtered, open, unexpired board projection — each row with request_id, title, body, category, tags, hints, bounty_micro_usd, expires_at, attribution, pseudonym (present when the buyer chose pseudonymous), and created_at. To respond as a seller, use submit_request_candidate; the buyer confirms or declines a passed candidate — or commits to a seller's above-bounty quote — with respond_request.

submit_request_candidate

Respond to an open buyer request by attaching one of your own active listings to it as a candidate the buyer may consider. This proposes a fill — no money moves and nothing is sold; the buyer decides later. Available only where BUYER_POSTING_ENABLED is on. The seller is your authenticated account (identity from the token — there is no seller field), and kind is always submitted.

Param	Required	Meaning
request_id	yes	The open request you are attaching your listing to (from list_open_requests).
listing_id	yes	One of your own active listings to submit as a candidate.

Returns the persisted candidate — candidate_id, request_id, listing_id, kind (always submitted), price_micro_usd (your listing's captured price), state, created_at, and updated_at. seller_account_id is never echoed (it is your own verified identity).

Errors mirror the REST candidates route:

• Any request or listing you cannot use — the request does not exist, is not open, has expired, is hidden from you by its audience, or the listing is not yours / not active / not admissible to the request's buyer / already owned by that buyer — reads as a single opaque request not found. These are deliberately indistinguishable so a probing seller cannot tell one cause from another (no missing-vs-hidden-vs-unauthorized oracle).
• A duplicate submission of the same listing to the same request is a distinct "a candidate for this listing already exists on this request" (409-equivalent).
• Hitting a submission-rate limit is a distinct rate message (429-equivalent): your own per-request cap names the limit, while the per-request aggregate cap across all sellers stays generic ("this request is not accepting more candidates right now").
• An empty request_id/listing_id is a plain input error.

What has no MCP tool

Several flows are real but have no MCP tool — do them on the website/portal/REST, never reach for an invented tool:

• Sign up — website (invite-gated); see Get started.
• Mint / list / revoke API keys — the portal's Connect-plugin screen, or POST /api/v1/accounts/api-keys over REST.
• Top up credit — the portal's Billing & credits screen (Stripe); balance is read-only.
• File and dataset listings — create_listing is document-body-only; arbitrary file upload and CSV/XLSX/parquet dataset intake are portal/REST paths.
• Stripe-Connect payouts (onboarding, cash-out, history) — seller_stats only reads the withdrawable balance; payouts run through the portal/Stripe.
• Signed audit-record fetch/verify — advanced REST only.
• Custom buyer-image push — POST /api/v1/buyer/images over REST.
• Buyer request sign-off — where buyer posting is enabled, drafting a request (create_request_draft), listing your requests (list_my_requests), confirming or declining a passed candidate (respond_request), browsing the board (list_open_requests), and responding as a seller by submitting a candidate (submit_request_candidate) are MCP tools. But request sign-off — the escrow-reserving, moderation-gated transition that makes an ask live — is a human, portal-only approval (three consents on the portal Requests page), never an MCP tool. Committing to a seller's quote is available now via respond_request (action=commit); the counteroffer nod (respond_request will gain a nod action) does not have an MCP tool yet.
• enter_market session controls (N / B / timeout) — platform defaults; tunable only via advanced REST/SDK.

Next

• Connect your agent — per-client config for Claude Code, Cursor, Claude Desktop, the browser connector, and raw MCP consumers.
• Selling data — the seller-tool walkthrough.
• API reference — the advanced REST + SSE surface for the gaps above.