Docs / How-to

Connect an Agent to
M2M Market.

From wallet and spending policy setup to production integration. Expand only the section you need; deep links automatically open the matching guide.

1 · Getting startedPrepare the Agent account

Sign in to the Agent dashboard, create or connect the production Agent wallet, fund it, and make sure the wallet has enough available balance for paid requests. Configure the spending policy before connecting application code.

Before integration, verify

  • Your Agent account is active.
  • The wallet is funded and available balance is positive.
  • A delegated authorization is active for the Agent signer.
  • Your per-query limit is high enough for the services the Agent may buy.
  • Any reputation or provider-selection requirements are intentional.
2 · Connection credentialCreate one revocable token per application

Open Agent → Connect Agent in the dashboard. Choose the delegated authorization to bind, give the credential a descriptive application name, select its expiry, and create it.

The connection token is displayed once. Copy it immediately and store it in your application secret manager or environment configuration. Do not commit it to source control. If a token is exposed or the application is retired, revoke it from the dashboard and issue a new one.

Security boundary: the connection token does not replace the wallet policy. Owner approval, delegated authorization, spending limits and provider-selection policy remain authoritative.
3 · Connection readinessTest before the Agent spends

The SDK exposes a connection test so an application can verify that its token and Agent are ready before attempting a paid request.

client = M2MConnectionClient.from_environment()
readiness = client.test_connection()
print(readiness)

The readiness response is designed to surface whether Agent details, spending policy, delegated authorization and funding are ready, including the currently available M2M balance. Run this during deployment checks and after credential or policy changes.

4 · EnvironmentConfigure the application secret

The Python and Node.js SDKs include https://api.m2mmarket.ai as their built-in production API URL. Only the connection token is required.

export M2M_CONNECTION_TOKEN="m2m_live_conn-..."

# Optional Python timeout
export M2M_REQUEST_TIMEOUT_SECONDS="30"
# Optional Node.js timeout
export M2M_REQUEST_TIMEOUT_MS="30000"

M2M_API_BASE_URL is optional and should only be set when deliberately targeting an alternate HTTPS deployment or test environment. Keep the connection token server-side; do not expose it in browser JavaScript or public client bundles.

Using AgentsAsk for an outcome in plain language

An Agent does not need to know which provider exists, what their input fields are called or how they are priced. It states what it needs, M2M finds a validated service that can answer, sends that service the inputs it expects, and settles only when the result is usable.

# Terminal
pip install --upgrade "m2m-market>=2.2.0"
export M2M_CONNECTION_TOKEN="m2m_live_conn-..."

# agent.py
from m2m_market import M2MConnectionClient

client = M2MConnectionClient.from_environment()

# Free preview: nothing is reserved and no provider is called.
preview = client.discover(intent="current weather in Nairobi today")
print(preview["resolved"]["input"])   # what M2M read from your text

# Buy the outcome.
result = client.ask("current weather in Nairobi today")
print(result["response"])

What M2M does with your sentence

  1. Understands the request. It works out the service type and the capability, for example current_weather.
  2. Reads the inputs from the text. A place, a date, a token, an address, a company, a question or a product, depending on the capability. Values are copied from your text, never invented.
  3. Matches only validated services. Each service was tested against an M2M contract for that capability before Agents can find it.
  4. Maps your inputs to the provider's own fields. A location you wrote once becomes city for one provider and q for another. You never see the difference.
  5. Checks the answer before settling. The reply must have the declared shape, and the fields you asked for. Otherwise the reservation is released and you are not charged.

Preview before you spend

discover is free. It returns resolved.input, the values M2M read from your text, and for every candidate a provider_input showing exactly what that provider would receive. If a value is wrong or missing, fix the sentence before buying.

Passing a payload is still allowed. If you send your own payload, it is used instead of reading the text. You can use M2M's standard field names (for example location) or the provider's own; M2M maps either.
Using AgentsGet reliable results: what an Agent should do

Plain language works best when the sentence is specific. Follow these steps in order of impact.

1. Write a specific sentence

  • Name the thing and its inputs: "current weather in Nairobi on 24 October 2026", not "weather".
  • Write places by name, dates explicitly (2026-10-24, 24 October 2026, tomorrow, next Friday), wallets and contracts as 0x... addresses, images as URLs, and text to embed or screen in quotes.
  • Avoid ambiguous numeric dates such as 03/04/2026. M2M asks for a clearer form instead of guessing.
  • "Today" and "now" mean the current date in UTC.

2. State the capability when you know it

This removes any guesswork about what the sentence meant. Pick it from the capability reference and pass it as required_capabilities. It matters most for short or unusual requests, and for sentences that mix topics ("write a haiku about rain" is a writing request, not a weather request).

3. List the fields you will rely on

Pass expect with the output fields your Agent needs, for example ["temperature_c", "conditions"]. Only services that declare those fields are considered, and a reply missing any of them is not settled.

4. Preview first, then buy

Call discover with the same sentence. Check resolved.input and the first candidate's provider_input. This is free and is the best way to catch a misread place or date.

5. Allow a fallback

Set maximum_attempts to 2 or 3 (up to your dashboard limit). If the first provider fails or breaks its contract, M2M excludes it and tries the next. Failed attempts are released and not charged.

6. Handle each outcome

  • settled: paid, and the response met the contract. Use it.
  • released: the provider failed or returned an unusable reply. Funds were returned. Retry or treat the request as unanswered.
  • intent_input_missing: a required input could not be read from your text. Nothing was reserved or paid. Add it to the sentence or pass a payload.
  • no_matching_service: no eligible service. Nothing was reserved or paid. Read error.payload["rejections"]: for example input_not_supported:date means no provider currently accepts that date.

7. Report the verdict

After using the result, call submit_acceptance (Python) or submitAcceptance (Node.js) with accepted set to true or false. It is recorded as evidence and does not change settlement.

Worked example

from m2m_market import (
    ConnectionExecutionPolicy,
    M2MConnectionClient,
    M2MNoMatchingServiceError,
)

client = M2MConnectionClient.from_environment()
policy = ConnectionExecutionPolicy(
    required_capabilities=["current_weather"],       # say what you need
    expect=["temperature_c", "conditions"],          # fields you will rely on
    maximum_attempts=2,                              # allow one fallback
)

intent = "current weather in Nairobi today"
try:
    result = client.purchase(intent=intent, policy=policy)
except M2MNoMatchingServiceError as error:
    # Nothing was reserved or paid. Read the reason.
    print(error.payload.get("rejections"))
else:
    print(result["response"])
    client.submit_acceptance(
        result["query_id"], acceptance_id="job-42", accepted=True
    )

What M2M guarantees, and what it does not

  • Guaranteed: the service passed validation for that capability, it received inputs it accepts, the reply has the declared shape and the fields you required, and you pay only when that is true.
  • Not guaranteed: that the content is correct or good. M2M cannot tell whether a temperature is accurate or a haiku is any good. Cross-check values your Agent acts on.
If something looks wrong, run discover with the same sentence and read resolved and rejections. They show how M2M understood the request and why services were skipped.
ReferenceCapabilities and the inputs they read

There are 24 built-in capabilities across nine categories. A provider picks the capabilities its service offers, and each one has an M2M contract the service must meet before Agents can find it. The table shows an example sentence and what M2M reads from it.

Weather & climate

  • current_weather: "current weather in Nairobi". Reads: a place, optional date.
  • weather_forecast: "weather forecast for Paris this weekend". Reads: a place, optional date.
  • precipitation_forecast: "will it rain in Kisumu tomorrow". Reads: a place, optional date.
  • historical_weather: "temperature in London on 2025-01-05". Reads: a place and a date.
  • air_quality: "air quality in Delhi". Reads: a place, optional date.

Market & pricing data

  • token_price: "price of ETH". Reads: a token name or symbol.
  • market_quote: "quote for BTC/USD". Reads: a market symbol or pair.
  • order_book: "order book for SOL/USDT". Reads: a market symbol or pair.

Risk & compliance

  • wallet_risk: "risk score for wallet 0x...". Reads: a wallet address (0x...).
  • sanctions_screening: "screen "Acme Trading LLC" for sanctions". Reads: a name in quotes, or an address.

On-chain intelligence

  • transaction_history: "transactions for 0x...". Reads: an address or transaction hash.
  • contract_analysis: "audit contract 0x...". Reads: a contract address.

Geospatial intelligence

  • geocoding: "coordinates of Kenyatta Avenue, Nairobi". Reads: an address or place name.
  • routing: "route from Nairobi CBD to JKIA". Reads: an origin and a destination (from ... to ...).
  • places_search: "coffee shops in Westlands". Reads: what to find, and a place.

Business & company data

  • company_profile: "company profile for Safaricom". Reads: a company name.
  • company_financials: "revenue of Apple Inc". Reads: a company name.

Search & knowledge

  • web_search: "search the web for latest x402 news". Reads: the search text.
  • knowledge_retrieval: "what is the M2M settlement fee?". Reads: the question.

AI inference

  • text_generation: "write a haiku about rain". Reads: the whole request is the prompt.
  • embeddings: "embed "agents buy outcomes"". Reads: the text to embed, in quotes.
  • image_analysis: "describe https://example.com/cat.png". Reads: an image URL.

Commerce data

  • product_search: "find running shoes under $100". Reads: the product to search for.
  • inventory_lookup: "is item SKU-12345 in stock". Reads: a SKU or product identifier.

Notes

  • A service in the Other category, or one created by an Administrator, has no built-in capabilities. Agents reach it by category and a payload, not by plain-language requests.
  • Older services that have not been validated can still be requested by category, but are never matched to plain-language requests, and they rank below validated services.
  • A provider that cannot take an input you gave is skipped, never silently answered without it. For example, a request for a past date is not answered with today's weather.
PythonInstall the Python SDK

Use the standard client when your Agent runtime is Python. The execution policy in code can further narrow a request, while the dashboard authorization remains the upper security boundary.

# Terminal
pip install --upgrade "m2m-market>=2.2.0"
export M2M_CONNECTION_TOKEN="m2m_live_conn-..."

# agent.py
from m2m_market import ConnectionExecutionPolicy, M2MConnectionClient

client = M2MConnectionClient.from_environment()

# Simplest: describe what you need.
result = client.ask("route from Nairobi CBD to JKIA")

# With limits: only tightens the dashboard policy, never loosens it.
result = client.purchase(
    intent="route from Nairobi CBD to JKIA",
    policy=ConnectionExecutionPolicy(
        required_capabilities=["routing"],
        expect=["distance_km", "duration_minutes"],
        maximum_price_m2m="0.05",
        minimum_reputation=80,
        maximum_attempts=2,
    ),
)
print(result["response"])

ask and purchase perform the complete task flow, including permitted provider failover attempts, status waiting and successful settlement completion. execute_task remains available for category-based requests with a payload.

Node.jsUse the Node package

For JavaScript or TypeScript Agent runtimes, install the same m2m-market package from npm and create the client from environment configuration.

# Terminal
npm install m2m-market@latest
export M2M_CONNECTION_TOKEN="m2m_live_conn-..."

// agent.mjs
import { M2MConnectionClient } from "m2m-market";

const client = M2MConnectionClient.fromEnvironment();

// Simplest: describe what you need.
const quick = await client.ask("route from Nairobi CBD to JKIA");

// With limits: only tightens the dashboard policy, never loosens it.
const result = await client.purchase({
  intent: "route from Nairobi CBD to JKIA",
  requiredCapabilities: ["routing"],
  expect: ["distance_km", "duration_minutes"],
  maximumPriceM2m: "0.05",
  minimumReputation: 80,
  maximumAttempts: 2,
});
console.log(result.response);

Keep M2M_CONNECTION_TOKEN in your server/runtime secret store rather than shipping it to a frontend.

REST / cURLIntegrate without an SDK

Any language capable of HTTPS can integrate directly with the connection endpoints. /connect/discover previews matches for free and /connect/execute buys. Send the connection credential as a Bearer token and the request as JSON. payload may be omitted when an intent is given.

export M2M_CONNECTION_TOKEN="m2m_live_conn-..."

# 1. Free preview. Nothing is reserved and no provider is called.
curl -X POST "https://api.m2mmarket.ai/connect/discover" \
  -H "Authorization: Bearer $M2M_CONNECTION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"intent": "current weather in Nairobi today"}'

# 2. Buy the outcome.
curl -X POST "https://api.m2mmarket.ai/connect/execute" \
  -H "Authorization: Bearer $M2M_CONNECTION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "intent": "current weather in Nairobi today",
    "required_capabilities": ["current_weather"],
    "expect": ["temperature_c", "conditions"],
    "maximum_price_m2m": "0.05",
    "maximum_attempts": 2,
    "response_format": "JSON"
  }'

If you integrate directly, preserve the task/query IDs returned by the API so your application can correlate status, retries and settlement records.

OpenAI toolExpose M2M as a model tool

The OpenAI adapter presents M2M Market as a tool the model can call when it decides an external paid capability is required.

# Terminal
pip install "m2m-market[openai]"

from m2m_market import (
    M2MConnectionClient,
    M2MToolAdapter,
    openai_tool_definition,
)

client = M2MConnectionClient.from_environment()
adapter = M2MToolAdapter(client)
tools = [openai_tool_definition()]

# Supply tools to your model. When it calls
# purchase_external_service:
result_json = adapter.invoke_json(tool_call.function.arguments)

Pass the generated tool definition to your model/tool-calling configuration. The model only has to supply an intent in plain language; payload is optional because M2M reads the inputs from the text. When the model requests purchase_external_service, pass the tool arguments to the adapter. M2M then applies the bound credential and spending controls.

LangChainAdd M2M as a LangChain tool

The adapter converts M2M into a LangChain-compatible tool that can participate in a tool-calling Agent alongside your other tools.

# Terminal
pip install "m2m-market[langchain]"

from m2m_market import M2MConnectionClient, M2MToolAdapter

client = M2MConnectionClient.from_environment()
m2m_tool = M2MToolAdapter(client).as_langchain_tool()

agent = create_tool_calling_agent(model, [m2m_tool], prompt)
executor = AgentExecutor(agent=agent, tools=[m2m_tool])

Your normal LangChain prompt and model remain in control of tool selection; M2M policy remains in control of whether the resulting purchase is allowed.

CrewAIGive a CrewAI Agent purchasing capability

Install the CrewAI extra and attach the generated M2M tool to the CrewAI Agent that needs external services.

# Terminal
pip install "m2m-market[crewai]"

from m2m_market import M2MConnectionClient, M2MToolAdapter

client = M2MConnectionClient.from_environment()
m2m_tool = M2MToolAdapter(client).as_crewai_tool()

agent = Agent(
    role="Service purchasing Agent",
    goal="Obtain trusted external API results",
    tools=[m2m_tool],
)

The CrewAI role and goal determine when the Agent wants the capability. M2M still applies the bound connection credential and spending controls before execution.

AutoGenRegister M2M as an AutoGen function

The AutoGen adapter exposes the M2M purchase operation as a function that can be registered with your AutoGen Agent.

# Terminal
pip install "m2m-market[autogen]"

from m2m_market import M2MConnectionClient, M2MToolAdapter

client = M2MConnectionClient.from_environment()
purchase_external_service = M2MToolAdapter(
    client
).as_autogen_function()

# Register purchase_external_service with your AutoGen Agent.

Register the returned function using your AutoGen version's normal function/tool registration mechanism.

x402Buy an x402 resource

M2M indexes x402 resources from the Bazaar catalog. For a listing that M2M marks as purchase eligible, an approved Agent can buy it through M2M. The Agent never signs a payment. M2M pays the seller and charges the Agent in M2M units, within per-purchase and daily limits. This is a limited capability: it is open only to Agents that M2M has approved for external purchases, and listings that are discovery-only cannot be bought.

Which request methods work

  • Supported: GET and POST. M2M sends the purchase with the method the listing declares, and with exactly the body you supplied.
  • Not yet enabled: PUT, PATCH and DELETE. Listings that use them are shown as not purchasable, and a purchase attempt is refused before any payment is prepared.
  • Not supported: HEAD, and listings that do not declare a method.

How to buy

  1. Search with POST /connect/x402/search. Each listing shows its method and whether it needs a request body.
  2. Call POST /connect/x402/purchase with the candidate_id and an idempotency_key. For a POST listing, also send body (a JSON object) and, if the listing takes one, query.
  3. Keep the same idempotency_key when you retry the same request. Reusing a key with a different method, body or URL is refused with idempotency_key_conflict.
export M2M_CONNECTION_TOKEN="m2m_live_conn-..."

# GET listing: send the candidate and a key you generate once per purchase.
curl -X POST "https://api.m2mmarket.ai/connect/x402/purchase" \
  -H "Authorization: Bearer $M2M_CONNECTION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "candidate_id": "<candidate_id from /connect/x402/search>",
    "idempotency_key": "<a new unique value>"
  }'

# POST listing: add the JSON body the listing asks for.
curl -X POST "https://api.m2mmarket.ai/connect/x402/purchase" \
  -H "Authorization: Bearer $M2M_CONNECTION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "candidate_id": "<candidate_id from /connect/x402/search>",
    "idempotency_key": "<a new unique value>",
    "method": "POST",
    "body": {"question": "example input"}
  }'

The price, recipient and resource address come from the listing and the seller's own payment challenge. Values you send for them are ignored. Put sensitive values in body, not query. M2M does not store the request body in its purchase journal. It stores a hash of it.

Describe what you need (SDK)

With the SDK you do not have to pick a listing or work out its request body. Call buy_external (Python) or buyExternal (Node) with a short description of what you need and the values to send. M2M searches the Bazaar, keeps the listings it can buy, matches your values to each listing's input schema by exact field name, and buys the cheapest listing your values satisfy. It never invents a value you did not supply, and no language model builds the request.

  • Dry run: pass dry_run=True (dryRun: true) to see the chosen listing, price and request, plus alternatives with their price and any missing fields. Nothing is charged, journaled or signed. On the REST route, send "dry_run": true to /connect/x402/purchase.
  • Price cap: max_price_usdc is optional. It can only lower the ceiling. Your Agent policy and the account limits always apply.
  • Results: a purchase status, or planned (dry run), needs_input (lists up to three candidates with their input schema and the missing fields, nothing charged), no_match, or over_price_cap.
  • One method: buy_external is all you need. Pass candidate_id to buy a specific listing instead of the cheapest, and use resume from a pending result to collect it. search_external and purchase_external are deprecated.
  • Fallback: another listing is tried only after a refusal that happened before any charge, up to three in all. After a charge, a pending result or paid_request_rejected, the call stops and never tries a different seller.
  • Schemas in search: listings from /connect/x402/search now include input.body_schema and input.query_schema when the seller declares them.
# Python (m2m-market 2.6.0 or later)
from m2m_market import M2MConnectionClient
client = M2MConnectionClient.from_environment()
# Check first: nothing is charged.
plan = client.buy_external("weather forecast", {"city": "Paris"}, dry_run=True)
# Then buy. max_price_usdc is optional and can only lower the ceiling.
result = client.buy_external("weather forecast", {"city": "Paris"}, max_price_usdc="0.01")
print(result["status"], result.get("purchase"))

// JavaScript
const result = await client.buyExternal("weather forecast", { city: "Paris" }, { maxPriceUsdc: "0.01" });

# Buy a specific listing taken from "alternatives" or "candidates", or collect a pending result
client.buy_external("weather forecast", {"city": "Paris"}, candidate_id="<candidate_id>")
client.buy_external(**result["resume"])

Refusals before any charge

These return an error and nothing is paid: method_unknown, method_unsupported, method_mismatch, input_required, input_invalid and idempotency_key_conflict. A request body or query that is too large is refused with HTTP 413.

When the seller rejects the paid request

If the seller answers the paid request with an error status, the result has the status paid_request_rejected, with the seller's http_status and a short reason code such as method_not_allowed. No result was returned by the seller. The charge stays pending until M2M checks the payment on the chain, then the purchase is released and the charge returned. M2M does not resend the paid request. Do not retry with a new idempotency key unless you intend to pay again.

What this does not mean: M2M does not check that the seller's content is correct, and listing a resource does not make it safe to buy. Other statuses, such as unknown_completion, mean the outcome needs review. Check the status and the charge before you retry.
TimingLatency and timing

Every purchase result includes timing, in milliseconds, so you can see whether time was spent on your network, in M2M, or at the Provider. The same breakdown appears in your console: open it from the icon next to a transaction's latency.

What each figure means

  • Your network: the SDK measures each call on your machine. call_ttfb_ms is the time to the first byte of M2M's answer (TTFB), call_ttlb_ms the time to the last byte (TTLB), and call_total_ms the whole call. The round trip between you and M2M (RTT) is your measured call time minus M2M's time for that call. For native purchases, submit_to_terminal_ms is the time from submitting until the result was ready.
  • M2M latency: m2m.request_ms is M2M's time before calling the Provider, m2m.response_ms its time after the Provider answered, and m2m.total_ms both together.
  • Provider: M2M's call to the Provider: dns_ms, connect_ms (one network round trip, also given as rtt_ms), tls_ms, sent_ms, then ttfb_ms and ttlb_ms measured from the start of the call, the HTTP status, and processing_ms_est, an estimate of the Provider's own processing time.

Estimates

One-way times, such as "you to M2M" or "Provider to M2M", are shown as half of a measured round trip, because the clocks on different machines never agree exactly. Provider processing is the time to first byte minus the connection and one round trip. These figures are marked as estimates.

Reporting your figures

After a purchase, the SDK sends its own figures to M2M once, in the background (POST /connect/timing), so your console can show your round trip too. This never delays or changes a purchase, and a dry run is not reported. It is on by default with the SDK's built-in transport. Turn it off with report_timing=False (Python) or reportTiming: false (Node).

API contractKnow the execution and status fields

Execution request

  • intent — plain-language outcome, for example "current weather in Nairobi". Provide this or category.
  • category — service category, such as weather_climate. Optional when intent is given.
  • required_capabilities — capabilities the service must offer, such as current_weather.
  • expect — output fields the result must contain; services that cannot supply them are not considered.
  • integration_types — optional filter, such as rest_api or mcp.
  • payload — optional JSON input. When omitted with an intent, M2M reads the inputs from the text. Required when you send only a category.
  • maximum_price_m2m — optional task ceiling that can only tighten dashboard policy.
  • minimum_reputation — optional provider reputation floor.
  • maximum_attempts — optional provider failover count; SDK execution permits 1–5 attempts.
  • response_format — defaults to JSON.
  • task_id, attempt_number and excluded candidates are used to maintain multi-attempt task continuity.

Status and completion

The Python client exposes get_query_status(query_id), get_task_status(task_id) and wait_for_query(query_id); the Node.js client has the equivalent getQueryStatus, getTaskStatus and waitForQuery. The current terminal query states handled by the SDK are settled and released. A successfully completed ask, purchase or execute_task result includes task context, provider/service identifiers, lifecycle state, attempt history and payment receipt data when available.

Spending policiesCode limits do not override dashboard limits

Treat request-level values such as maximum_price_m2m and minimum_reputation as narrower task rules. They cannot grant authority that the dashboard policy does not already permit. The active delegated authorization remains authoritative.

Recommended production pattern

  • Use the smallest practical per-query ceiling.
  • Issue separate credentials for separate Agent applications.
  • Use meaningful credential expiry instead of permanent tokens.
  • Revoke unused or compromised credentials immediately.
  • Keep owner recovery authority separate from Agent execution secrets.
Execution lifecycleUnderstand the full request path
  1. Authenticate: M2M validates the connection token and bound delegated authorization.
  2. Discover: the request is understood, its inputs are read, and it is matched to eligible validated provider services.
  3. Authorize: price, reputation, attempt and spending constraints are checked.
  4. Dispatch: the request is sent to the selected provider.
  5. Respond: the provider result is checked against the service contract and your expect fields, then returned to the Agent. A reply that fails the check is not settled.
  6. Settle: a successful interaction moves through M2M settlement and becomes observable in transaction history.

When a provider attempt does not complete the task, the SDK can obtain task status, apply required exclusions, advance to the next permitted attempt and avoid blindly retrying the same candidate.

ProvidersPublish the capabilities Agents consume

Provider onboarding is the other side of these integrations. Register a provider profile, publish the service category and endpoint, define the price, keep the endpoint healthy, and monitor requests, responses, reputation and earnings from the Provider dashboard.

Explore the Marketplace model →

TroubleshootingDebug by lifecycle stage

Connection rejected

Check that the token is correct, active, unexpired and not revoked. Confirm it is bound to an active delegated authorization. If you provide an M2M_API_BASE_URL override, the SDK requires it to use HTTPS. Connection tokens must have the expected m2m_live_conn- prefix.

Request blocked before provider execution

Check wallet funding, per-query allowance, requested price ceiling, minimum reputation and provider-selection constraints.

No eligible provider

The error carries a rejections block that says why services were skipped. Common reasons: payload_schema with input_not_supported:date (no provider takes that date), a missing capability, an expected field no service declares, a price above your limit, or reputation below your minimum. Run discover with the same request to see them without spending.

Input missing from the request

intent_input_missing means a required value, such as the place, could not be read from your sentence. Nothing was reserved. Add it to the sentence or pass a payload.

Request understood as the wrong service

Pass required_capabilities to state the capability. Sentences that mix topics can be read the wrong way.

Provider execution failed

Inspect the task/query status and attempt history. Respect the configured maximum attempts rather than retrying indefinitely.

Long-running query

The Python SDK waits for query completion with a configurable timeout and polling interval. Treat timeout as an unresolved state to inspect, not proof that settlement failed.

Response succeeded but settlement is unclear

Use the dashboard transaction and live-network surfaces to verify the settlement stage separately from the provider response stage.