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.
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
- Understands the request. It works out the service type and the capability, for example
current_weather. - 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.
- Matches only validated services. Each service was tested against an M2M contract for that capability before Agents can find it.
- Maps your inputs to the provider's own fields. A location you wrote once becomes
cityfor one provider andqfor another. You never see the difference. - 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.
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 as0x...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 apayload.no_matching_service: no eligible service. Nothing was reserved or paid. Readerror.payload["rejections"]: for exampleinput_not_supported:datemeans 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.
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:
GETandPOST. M2M sends the purchase with the method the listing declares, and with exactly the body you supplied. - Not yet enabled:
PUT,PATCHandDELETE. 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
- Search with
POST /connect/x402/search. Each listing shows itsmethodand whether it needs a request body. - Call
POST /connect/x402/purchasewith thecandidate_idand anidempotency_key. For aPOSTlisting, also sendbody(a JSON object) and, if the listing takes one,query. - Keep the same
idempotency_keywhen you retry the same request. Reusing a key with a different method, body or URL is refused withidempotency_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, plusalternativeswith their price and any missing fields. Nothing is charged, journaled or signed. On the REST route, send"dry_run": trueto/connect/x402/purchase. - Price cap:
max_price_usdcis 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, orover_price_cap. - One method:
buy_externalis all you need. Passcandidate_idto buy a specific listing instead of the cheapest, and useresumefrom apendingresult to collect it.search_externalandpurchase_externalare deprecated. - Fallback: another listing is tried only after a refusal that happened before any charge, up to three in all. After a charge, a
pendingresult orpaid_request_rejected, the call stops and never tries a different seller. - Schemas in search: listings from
/connect/x402/searchnow includeinput.body_schemaandinput.query_schemawhen 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.
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_msis the time to the first byte of M2M's answer (TTFB),call_ttlb_msthe time to the last byte (TTLB), andcall_total_msthe 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_msis the time from submitting until the result was ready. - M2M latency:
m2m.request_msis M2M's time before calling the Provider,m2m.response_msits time after the Provider answered, andm2m.total_msboth together. - Provider: M2M's call to the Provider:
dns_ms,connect_ms(one network round trip, also given asrtt_ms),tls_ms,sent_ms, thenttfb_msandttlb_msmeasured from the start of the call, the HTTPstatus, andprocessing_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 orcategory.category— service category, such asweather_climate. Optional whenintentis given.required_capabilities— capabilities the service must offer, such ascurrent_weather.expect— output fields the result must contain; services that cannot supply them are not considered.integration_types— optional filter, such asrest_apiormcp.payload— optional JSON input. When omitted with anintent, M2M reads the inputs from the text. Required when you send only acategory.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 toJSON.task_id,attempt_numberand 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+
- Authenticate: M2M validates the connection token and bound delegated authorization.
- Discover: the request is understood, its inputs are read, and it is matched to eligible validated provider services.
- Authorize: price, reputation, attempt and spending constraints are checked.
- Dispatch: the request is sent to the selected provider.
- Respond: the provider result is checked against the service contract and your
expectfields, then returned to the Agent. A reply that fails the check is not settled. - 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.
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.