Last Price MCP Server

Record one competitor price observation by hand, for the pipeline to match against your catalog: a competitor's observed price for a product. The cycle usually collects these itself. Needs a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Link a store to the commerce pipeline: platform is one of the platforms list_commerce_connectors offers. Store credentials go in credentials; they are kept encrypted and never returned, but they do pass through this conversation, so use a key made for the purpose. The metadata also sets where competitor prices come from. Needs the owner or admin role and a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Create a commerce pricing policy: the rules the pipeline uses to draft price proposals, with an optional floor and ceiling and an approval mode. Starts active. Needs a Last Price credential with commerce configure scope, and a claimed workspace. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a commerce pricing policy for good. To keep it but stop the pipeline using it, switch it off with update_commerce_policy. Needs a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one commerce pricing policy: its scope and rules. policy_id is the id from list_commerce_policies. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the commerce audit trail for your workspace: what the pipeline drafted, approved, rejected and executed. This is the commerce trail, separate from list_audit_events. Filter by subject_kind and subject_id, for example proposal and a proposal id. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the catalog items the commerce pipeline tracks for your workspace: each product the cycle prices, with its current price and source. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the store connectors linked to your workspace (credentials are never shown) and the platforms you can connect. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the recent competitor price observations the commerce pipeline collected: source, competitor, observed price and time. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the pricing policies the commerce pipeline applies when it drafts price proposals: each policy's id, scope, rules and whether it is enabled. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the price proposals the commerce pipeline drafted, newest first, each with its status (proposed, approved, rejected, executed, failed or expired), the current and proposed price and the policy that produced it. Filter by status. Needs a Last Price credential with commerce catalog read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Run the commerce pipeline once: pull catalogs and competitor prices, match them, apply the policies and draft price proposals. By default it is a dry run that drafts proposals and pushes nothing to a store. With execute true it also pushes approved proposals to the connected store, which changes live prices and needs the commerce execute scope as well. Needs a Last Price credential with commerce proposal draft scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Pause or resume a linked store. A paused connector is skipped by the cycle and by execution. connector_id is the id from list_commerce_connectors. Needs the owner or admin role and a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a commerce pricing policy. Only the fields you send change; rules replace the whole rule list. policy_id is the id from list_commerce_policies. Needs a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add a DNS record to a domain your workspace registered through Last Price, to use it for more than the storefront: MX for email, TXT for SPF, DKIM, DMARC or site verification, CNAME or A for a subdomain. name is relative (blog for blog.<domain>, empty for the domain itself). Records the storefront needs cannot be replaced. Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Serve a storefront on a domain your company owns (white label), such as agents.yourcompany.com. Answers with two DNS records to add at your DNS provider: a TXT record proving you own the domain and the record that routes it. Then call verify_storefront_domain. Last Price domains and hosting domains are refused. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Create a storefront: an agent card, llms.txt and MCP endpoint listing a selection of your public offers at <subdomain>.store.last-price.ai (and /s/<subdomain> on last-price.ai). display_name is required; the subdomain defaults to one made from it. It stays unpublished unless published is true. A workspace may run several, one per product line or audience, but each must list a different selection (offer_tags, product_ids or the kinds shown): the same offers twice is refused. Every storefront says it is powered by Last Price. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a storefront and its domains. Its addresses stop answering at once. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one storefront with its domains, addresses and the offers it lists right now. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the DNS records of a domain your workspace registered through Last Price. locked marks the records the storefront needs. A domain bought elsewhere is refused: manage its DNS where it was bought. Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List a storefront's domain quotes and registrations: domain, years, price, and quoted, ordered, failed or expired. Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Remove a DNS record from a domain your workspace registered through Last Price. Records the storefront needs cannot be removed. Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Stop serving a storefront on one of your domains. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Find a domain for a storefront: send query (a name, tried with .com, .ai, .io, .co, .app, .dev, .shop and .store) or domains (up to 50 exact ones) and get whether each is available and its first-year price in USD. Read-only: nothing is registered or paid. Only where the workspace has storefronts and domain search switched on (else an error with code not_released). Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a storefront. Only the fields you send change; an empty string clears optional text. Set published to put it live or take it down. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Run the free agent-ready check on a store: pass url, the store address. It reports whether shopping agents can check out, whether bot blocking is in the way and whether margin survives an agent's cut. It fetches the store, so it is limited per address and answers 404 while the check is not released. Public: needs no credential.

Read one behaviour test run for one of your agents, with every scenario's result. In early access: it answers released false or not_released until it is switched on for your workspace. Runs never send real mail. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read what the behaviour tests offer for one of your agents: whether they are released for your workspace, the scenario pack for the agent's kind, whether your workspace's own Anthropic key is connected, the limits and the recent runs. In early access: it answers released false or not_released until it is switched on for your workspace. Runs never send real mail. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read what one agent may do: its effective scopes with a description of each, how many approvals are pending for it, its rate limit and how idempotency keys work. Pass agent_id. Call it before a planned action to learn whether it will succeed instead of meeting a 403. An agent's own credential reads only its own agent; a workspace credential reads any agent in the workspace. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your Personal Agent Protocol file: the organization name and domain saved for it, whether the domain is verified, the file to publish (the poppy.json a personal agent reads to learn what you let it do) and the address to publish it at. Answers released false until agent protocol files are switched on for your workspace. Read-only. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one agent's Value Receipt, measured: its signals over the period with the human value the workspace set for each, what it cost (Last Price compute plus costs recorded in the workspace) and the return when both are known. A figure that cannot be measured is null, with the reason under missing. Pass agent_id, and start_date and end_date to choose the period (default the last 30 days, at most 366). An agent's own credential reads only its own receipt. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Run the behaviour test scenarios against one of your agents and answer the stored run with every scenario's result. It uses your workspace's own Anthropic key, so the model calls are billed to that key, and it is limited to 20 runs a day. Pass scenario_ids to run only some scenarios, or system_prompt_override to test a draft prompt. In early access: it answers released false or not_released until it is switched on for your workspace. Runs never send real mail. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Save the organization name and domain your Personal Agent Protocol file carries: pass organization_name and domain (a host name such as acme-outdoor.com). A new domain gets a new verification value and has to be checked again. Returns the file to publish at https://<domain>/.well-known/poppy.json; publish it exactly as given, then call verify_agent_protocol. Answers 404 until agent protocol files are switched on for your workspace. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Grant a customer a prepaid credit bundle: pass customer_id and amount, and optionally currency (default USD), expires_at and metadata. The balance starts at the amount. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Create a credit bundle to sell: a name, price, billing frequency and credits (null for unlimited). status active puts it on sale now; inactive (the default) saves it to activate later. Without a code, one is made from the name. Early access. Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a credit bundle and the balance left in it: pass credit_id. It cannot be undone by another tool, so check it with get_credit first. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one prepaid credit bundle: its customer, amount bought, balance left, currency and expiry. Pass credit_id. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

The credit a customer has left to spend: the total of their unexpired bundles with a balance, per currency. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the credit bundles your workspace sells: each one's id, name, code, price, billing frequency, credits (null for unlimited), rollover and status (active, inactive or archived). Early access: answers released false with no bundles until credit bundles are switched on for the workspace. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the customers on a recurring credit bundle (monthly, quarterly or annually), newest first: each subscription's customer, status, current period and when it renews, and why it was cancelled. Granting a recurring bundle starts one; each period end renews it with the bundle's credits plus the rollover. Early access. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a credit bundle: activate it (status active), take it off sale (inactive), archive it, or change its name, description, price, credits or rollover. Code and currency are fixed. Early access. Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Register a pricing function in your workspace. execution_type is how it prices: rule based, ML model, LLM prompt, external API (your own endpoint) or composite. name is its unique lowercase id, such as acme/surge. Set is_public to list it for other workspaces. A new function starts as a draft unless status is active: make it active with update_function to have it routed to. A rule_based function prices by the rule you send (base, then steps such as margin, tiers, floor and price ending). Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a pricing function your workspace owns, for good. Built-in functions and other workspaces' functions cannot be deleted. To stop routing to one without losing it, set its status to inactive with update_function instead. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one pricing function your workspace can use: its name, description, status, tags, cost per unit, cost multiplier, and input and output schemas. Its owner also sees whether a credential is saved for it. Needs a Last Price credential with function read scope.

Read the endpoint health of one of your external functions: the most recent probes, newest first, each with when it ran, whether it passed, its latency and any error, and whether the hourly probe covers the function. Pass function_id. Only the owner can read it. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the latest marketplace review of one of your functions, from its listing: the report, whether the listing is public and the listing id. The review is null when the function has no listing or was never reviewed. Pass function_id. Only the owner can read it. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Probe the endpoint of one of your external functions now: one sample call, recorded with the history and fed into the router's circuit breaker. Pass function_id. It calls your endpoint, so a function that is not active and external with an endpoint URL is refused. Read the history with get_function_health. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Run the marketplace review of one of your functions now, as a dry run: it makes one sample call to the function, stores the report on the listing when there is one and never changes whether the listing is public. Pass function_id. The sample call spends your endpoint or provider key. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a pricing function your workspace owns: its display name, description, status, tags, cost per unit, cost multiplier, endpoint, credential, schemas or model configuration. Only the fields you send change. Built-in functions and other workspaces' functions cannot be changed. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Remove your workspace's saved price guardrails so the defaults apply again. It answers the defaults. Read what is saved first with get_price_guardrails, because this cannot be undone by another tool. Needs a claimed Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

One check from the workspace's price history with its whole answer, as price_from_capture first gave it: the item and its condition, the price, range and confidence, the reason, prices read off tags or listings, what would make it sharper, and the listing (selling) or message to the seller (buying). check_id is the id from list_price_checks, or the check_id price_from_capture returned. The photos, files, links and text sent are never kept, only the answer. Another workspace's id, or an unknown one, is a 404. Changes nothing. Until price history is switched on for your workspace it answers 404 not_released. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read whether your workspace explores prices: learned and optimizer prices for the same product then vary slightly from call to call, by up to the rate either way (steered toward the best price, at most 10%, once enough is learned), so Last Price can learn what buyers will pay. Never below cost and always inside your price guardrails. Shows whether it is on and why, the rate, and the bounds. Needs a Last Price credential with routing read scope.

Read the price guardrails saved for your workspace, and the defaults set_price_guardrails fills in for an omitted field. saved is false when none are saved, and then no workspace limit applies. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

The workspace's price history: every price from a photo, link, PDF or text, newest first, whichever way it was asked (surface app for the phone app or website, api, or mcp for a chat app such as ChatGPT or Claude). Each check has its id, created_at, the item, side (selling or buying), the price with its low to high range and currency, confidence (0 to 1) and share_url. Use it to know what the person has already priced, for example to answer "what did I price last week" or before pricing the same thing again. q finds checks by words in the item's name; limit (1 to 100, default 20) sets the page size, and before takes the next_before of the last page for older checks (next_before is null on the last page). get_price_check gives one check's whole answer. Changes nothing. Until price history is switched on for your workspace it answers 404 not_released. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Price an item from what you have about it, the way a person would look at it: send photos, screenshots, PDFs, product page links, a description or a barcode in artifacts and get one price with its range, what the item is and its condition, any prices read off the attachments, and a write-up for your side of the sale: a listing to post with the price when selling, or a message to the seller with your opening offer filled in when buying. side says which (selling by default); the value is the same either way, and the range reads as quick sale to top of range for a seller and opening offer to most to pay for a buyer. current_price is the price you have in mind: it is compared with the estimate, never used as it. No item recognized means no price (computed_price null, confidence 0), never a guess. With a price, share_url is a public link to a card showing it, to send to the person or post with the listing. check_id is its place in the workspace's price history (list_price_checks, get_price_check) where that is kept. A photo or PDF goes as base64 with its mime_type, or as a public http or https link to the file; the hosted MCP endpoint takes requests up to 64 KB, so send larger photos as links. A photo on disk with no link: with a shell, upload it in one command instead, with the same answer: curl -X POST https://api.last-price.ai/api/price-router/pipelines -H "x-api-key: YOUR_KEY" -F [email protected], adding -F [email protected], -F [email protected], -F text="...", -F side=buying or -F current_price=120 as needed (about 4 MB per request in all). In a chat app that hands attached files to tools (ChatGPT), a photo or PDF the person attached goes in photo or file as it arrives. One model call reads everything (your workspace's own Anthropic key when it has one), so allow up to 30 seconds; it is recorded as model usage, not drawn from your balance, and changes no price or setting. Until it is switched on for your workspace it answers 501. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Turn price exploration on or off for your workspace, set its rate (at most 10% either way), or set how far past the prices already tried the optimizer may go (beyond_pct, 1 to 10%, default 5). It is on by default while learned pricing is on; turning it off gives every learned price exactly as computed. A field left out keeps its saved value. Needs a Last Price credential with routing write scope; from the dashboard, an owner or admin.

Save the price guardrails for your workspace. max_change_pct, min_margin_pct and never_below_cost hold every final price your workspace is given, from compute_price and every other pricing call. band_lower_ratio and band_upper_ratio are only the range the optimizer and elasticity functions search when a call sends no minimum or maximum. This replaces the whole saved set: an omitted field takes its default, so read get_price_guardrails first and send every rule you want to keep. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List one of your functions on the marketplace: pass function_id, and optionally is_public (default false), commission_rate (default 0.30), min_payout_threshold (default 50) and payout_currency (default USD). A listing made public is reviewed first; a function that fails the review is saved private and the refusal carries the report. Where payouts go is set by a person, not by this tool. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Remove one of your marketplace listings: pass listing_id. The function stays; it is no longer listed. Only the owner can remove a listing. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the payout ledger for the functions you own on the marketplace: what each call earned, its commission and its payout status. Filter by payout_status and page with limit and offset. Read-only. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Browse the public marketplace: the pricing functions their owners listed for anyone to use, each cut to its public fields, with usage and rating. Page with limit and offset. Public: needs no credential, limited per address.

List your own marketplace listings, public or not. Page with limit and offset. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change one of your marketplace listings: pass listing_id and at least one of is_public, commission_rate and min_payout_threshold. Making a private listing public runs the marketplace review first; a function that fails it stays as it was and the refusal carries the report. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add a line item to an order: pass order_id, description and unit_price, and optionally quantity (default 1) and metadata. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add an order for a customer: pass customer_id, and optionally agent_id, billing_contact_id (a contact of that customer), status (default draft), total_amount (default 0), currency (default USD) and metadata. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete an order and its lines: pass order_id. Only a draft or cancelled order can be deleted; cancel it first otherwise. It cannot be undone by another tool. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one order: its customer, status, total, currency and metadata. Pass order_id. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the line items on an order, oldest first: pass order_id. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change an order: pass order_id and at least one of status, total_amount, currency, metadata and billing_contact_id; null clears the billing contact. An order that has left draft cannot return to it. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Create a hosted scrape job that reads prices from one public https page with CSS selectors, on a schedule or on demand with run_scrape_job. Try the selectors first with preview_scrape_job. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a scrape job and its run history. This cannot be undone: update_scrape_job with enabled false pauses it instead. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the runs of one scrape job, newest first: when each ran, its status and the prices it found. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:catalog:read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's hosted price scrape jobs: each one's id, name, page url, selectors, schedule and whether it is enabled. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:catalog:read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Run a scrape job now: fetch its page once, read the prices with its selectors and record the run. The answer is the run, with the prices found and its status. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a scrape job: send job_id and only the fields you want to change, at least one. Set plan_selector to null to clear it. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Open a UCP checkout session: pass line_items, and optionally buyer, context, payment, signals, cart_id, fulfillment, discounts, currency, idempotency_key and agentid_token. Pass the same idempotency_key with the same body to retry safely: you get the first session back instead of a second one. Pass agentid_token to have the session record you as a verified buying agent. It answers the session with its id and status. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one UCP checkout session: pass checkout_id. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read Last Price's Universal Commerce Protocol business profile: the services, capabilities and payment handlers a UCP agent discovers before it shops here. Public: needs no credential.

Price a cart the UCP way: pass cart with line_items, and optionally request_id, function_id, routing_preference, currency, stage (quote, cart, checkout or order), checkout, order, payment, context and agentid_token. It routes the cart through the pricing network and answers a UCP quote. Pass agentid_token (an AgentID ID token issued for Last Price) to be recorded as a verified buying agent; the answer then names you, marked verified. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's UCP checkout sessions, with each one's id, status and totals. Read-only. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a UCP checkout session that is still open: pass checkout_id and at least one of line_items, buyer, context, payment, signals, fulfillment and discounts. A completed or canceled session answers 422. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add a contact to a customer: pass customer_id, name and email, and optionally external_id (unique within the customer), phone, address and metadata. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a contact: pass contact_id. This removes the record, and it cannot be undone by another tool. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one contact: its name, email, phone, address, external id and metadata. Pass contact_id. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one contact by the id your own system gives it: pass external_id and customer_id, because an external id is only unique within one customer. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a contact: pass contact_id and at least one of name, email, phone, address, external_id and metadata; null clears phone, address or external_id. A contact cannot be moved to another customer. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add a customer: pass name, and optionally email, external_id (your own id for it) and metadata. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a customer: pass customer_id. This removes the record, and it cannot be undone by another tool, so check it is the right one with get_customer first. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one customer: its name, email, external id and metadata. Pass customer_id. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one customer by the id your own system gives it: pass external_id. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a customer: pass customer_id and at least one of name, email and metadata. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Create a price experiment in draft. It needs two to ten variants, one named control, each with a price; weights are optional but must then be on every variant: relative for two variants, whole percentages adding up to 100 for more. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one experiment's definition: its key, name, description, status, variants with their prices and weights, target sample size and dates. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read how an experiment is doing: for each variant the views, conversions, conversion rate and revenue, and a comparison of every variant against the control. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read whether one of your stored experiments can stop: the verdict (stop, keep running, or no winner yet) with its reason and a one-line headline, from a sequential test against control that stays valid however often you look (mSPRT, adjusted for the number of arms), with each arm's chance to beat control and expected loss. Also the traffic split in force now, whether bandit allocation is on with its floors and the weights it would set now, and the weight history: every change the bandit made and every change to its settings. Answers "not enabled" until sequential testing is switched on for your workspace. Needs a Last Price credential for the workspace that owns the experiment. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Switch bandit allocation on or off for one of your stored experiments, and set its floors: pass experiment_key and bandit_enabled, and optionally min_weight_pct (1 to 50, the least traffic any arm keeps) and control_min_weight_pct (1 to 90, the least control keeps). The floors have to fit the number of arms. Read the result with get_experiment_stopping. Answers "not enabled" until sequential testing is switched on for your workspace. Needs a claimed Last Price credential for the workspace that owns the experiment. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Remove your workspace's feature contract: quotes are logged without contract labels again. Needs a Last Price credential with routing write scope; from the dashboard, an owner or admin.

Read your workspace's feature contract: which fields of a pricing request, nested metadata included, your buyer-aware pricing models learn from, each named by its path in the API, and the column each one gets in an ONNX export. While one is saved, each logged quote keeps only these labels, never raw metadata. Not available until feature contracts are switched on for your workspace. Needs a Last Price credential with routing read scope.

Read one launch kit's plan, for Last Price staff only: its checks, its steps in the order the launch runs them (marking the ones that send something outside Last Price), its go code, and the exact words the owner says to launch it ("go CODE", "go CODE at <UTC time>", or "go CODE without announcements"). Read only: it never switches, schedules or sends anything; launching needs the owner's go code through the launch command. Needs an API key holding the launches:read scope by name, made by someone who is still Last Price staff, sent as x-api-key or as Authorization: Bearer lp_...; any other credential gets 404. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List every launch kit for a feature built behind a release flag, for Last Price staff only: the flag's state, readiness (how many checks pass, warn and fail, and what blocks), the go code, what is scheduled, whether the launcher is on, and the release flags that have no kit yet. Read only: it never switches, schedules or sends anything; launching needs the owner's go code through the launch command. Needs an API key holding the launches:read scope by name, made by someone who is still Last Price staff, sent as x-api-key or as Authorization: Bearer lp_...; any other credential gets 404. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Save your workspace's feature contract, replacing the one saved: the request fields, by API path, your buyer-aware pricing models learn from, and how each becomes a label (a category, a numeric bin or a flag). Fields that identify a person are refused. Needs a Last Price credential with routing write scope; from the dashboard, an owner or admin.

See how buyers react to price, the data behind the chart on the learned pricing page: quotes with a reported outcome grouped into bins of quoted over current price (counts only), the fitted acceptance line with its 95% band, what a 10% raise does to sales by that line, and how the estimate moved over time. Covers the pooled workspace estimate, or one product with product_id. Owners and admins only. Needs a Last Price credential with routing read scope.

Read learned pricing for your workspace: whether the default optimizer prices from the elasticity learned from your own quotes and their outcomes, how new estimates are applied (auto or approve, null until chosen), the mode it runs in now (off, preview, auto or approve), whether owners and admins are emailed, every estimate per product and pooled over the workspace with an example price it gives against the assumed default (also while learning is off, as a preview), progress toward what an estimate needs, and the recent changes. Needs a Last Price credential with routing read scope.

Read what learned routing has learned for one of your routing policies: for each function the policy can choose, the calls seen, the success rate, the latency and rate the reward used, the expected reward with an interval, and the share of calls it would route there now. learning says whether it decides the policy's traffic; reason says why not: it is not released for your workspace, the policy has not turned it on, the policy's strategy is not one it can stand in for, or it is still collecting data, and meanwhile the policy's own strategy decides. Read only. Leave policy_id out for your default policy. Pass strategy instead to read what it learned for compute_price calls that name that strategy and turn learned routing on (no policy). Needs a Last Price credential with routing read scope.

List the changes learned pricing recorded for your workspace, newest first: for each product (or all products), the elasticity before and after, an example price before and after, and its status. status pending lists what waits for your decision; pass its id to decide_learned_price_change. A signed webhook announces each one as it happens, with its id. Needs a Last Price credential with routing read scope.

Turn learned pricing on or off, choose how new estimates are applied, or turn its email on or off. Only the fields you send change. apply_mode is optional: turning it on without one keeps the saved mode, or else runs in preview (changes recorded, no price moves) until the automatic default is released; mode in the answer says which. auto applies each new estimate at once and announces every change; approve keeps pricing on the last approved estimate until you approve each change with decide_learned_price_change. enabled false keeps the saved mode. Needs a Last Price credential with routing write scope, or the key of the agent that registered an unclaimed workspace, which owns it.

Read how your workspace takes offers and counter-offers from buyers: whether offers are on, your public handle, the rounds, concession and expiry limits, the products open to offers with their list and floor prices, the last 30 days' negotiations, and the public URLs a buyer's agent uses. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read a seller's negotiable terms by their public handle: which products are open to offers, at what list price and currency, how many offers a negotiation allows and how long a counter stands. Never the floor price. Pass product_id to narrow it to one product. Public: needs no credential. An unknown handle, a seller with offers off and a product that is off all answer not found.

Take a product off offers. Negotiations already open on it stop, because a product that is not listed answers buyers with not found. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Open one product to offers, or change it: this saves the product whole (create or replace). Buyers see the list price and never the floor price, which is never breached; the floor cannot exceed the list price. Each product has its own switch, off unless you set enabled. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Turn offers and counter-offers on or off for your workspace and set the schedule every negotiation runs on. Omitted fields keep their saved value, or the default. A handle another workspace holds is refused. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add a routing policy: how a price request picks a pricing function. The strategy is cheapest, fastest, explicit, round robin, weighted (needs weights with at least one above zero), policy (rules that send matching requests to a function) or default. Set is_default to make it the policy used when no function is named; that replaces the current default. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a routing policy. This cannot be undone. Price requests that named no function stop using it. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one routing policy: its name, strategy, config, fallback function and whether it is the default. Needs a Last Price credential with routing read scope.

List your workspace's routing policies: each one's id, name, strategy, config, fallback function, and whether it is the default. Only the default policy is used when a price is computed without naming a function. Needs a Last Price credential with routing read scope.

Change a routing policy. Only the fields you send change; config replaces the whole config. The strategy must still be usable with the config that results. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Check the Personal Agent Protocol file you published: Last Price fetches https://<domain>/.well-known/poppy.json and compares it with the one get_agent_protocol gives. A match verifies the domain for your workspace; a failure returns reason and message saying what to fix, and a domain another workspace verified answers 409. Answers 404 until agent protocol files are switched on for your workspace. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Ask whether a price makes sense for its context, rather than what the price should be. Returns a verdict (fair, too_high, too_low, or unknown), the band it was judged against, a signed deviation from the reference, a confidence, and the evidence behind it. A verdict of "unknown" means the price could not be judged, which is not the same as fair. Pass quote_valid_until from the compute_price result the price came from, and where quote expiry is switched on the answer says quote_expired when that quote is stale. Where buyers' spend limits are switched on and metadata.category names a category, the evidence includes buyer_budget: what buyers' own spend checks allowed for it (buyer_envelope), reported and never counted in the verdict.

Check a signed price quote you received from a seller: was it issued by Last Price, is it unaltered, and is it still valid. Pass its jws string. A quote that fails still answers: valid is false and reason says why (a forged signature, or expired, which still returns the claims). Public: needs no credential. It answers 501 while signed quotes are off on this deployment, and you can instead verify offline against the public keys at /.well-known/quote-keys.json.

Check a storefront domain's TXT record now. verified true means the domain is proven yours and the storefront answers there once routing is in place; otherwise reason and detail say what is missing. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Check a webhook signature the way Last Price signs them: pass payload (the raw body, up to 8 KB), signature and secret, and optionally encoding (hex or base64) and prefix. Answers whether it is valid. Public and limited per address; use a test secret rather than a live one when you can, because the secret travels in the request. Needs no credential.

Add an invoice for a customer: pass customer_id and amount, and optionally invoice_number, currency (default USD), due_date, status (default draft) and metadata. It does not email the customer; send_invoice does. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete an invoice: pass invoice_id. It cannot be undone by another tool. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one invoice: its customer, number, status, amount, currency and due date. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change an invoice: pass invoice_id and at least one of status, amount, currency, due_date and metadata. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one payout run with its Stripe transfers: each transfer's status (pending, processing, paid, waiting for a retry, or failed), attempts, last error, next retry time, Stripe transfer id and idempotency key. Answers 404 while payout runs are not switched on for your workspace (list_payout_runs says so in execution.enabled). Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your workspace's payout schedule: whether it is on, weekly or monthly, its run day, whether it retries transfers on its own, the next run day, the period that day will request and what the last run day did. schedule is null when none is saved. Payout schedules are part of payout runs: while those are not switched on for your workspace, execution.enabled is false and schedule is null. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's marketplace payout runs, newest first: each run's id, status (a dry run, awaiting approval, rejected, stale, approved, processing, partial, paid or failed), period, total, Stripe mode, the transfers it plans and the entries it skips, who requested it and who decided it. execution says whether payout runs are switched on for your workspace and whether Stripe is ready. They are not switched on for every workspace yet: while they are off for yours, execution.enabled is false and no runs are listed. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Save your workspace's payout schedule whole. On each run day (UTC) a payout run of every unpaid ledger entry whose billing period has ended is requested in the name of whoever saved the schedule, so it still waits for approval by someone else, never by that saver; while a request is still waiting, the next run day requests nothing new. Turning it on needs a person behind the credential: a signed-in user, or a key or agent a person created. Answers 404 while payout runs are not switched on for your workspace (list_payout_runs says so in execution.enabled). Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read what your workspace's own records say about its pricing, as findings, most urgent first: learned estimates ready while learned pricing is off, estimates that cannot be used yet and exactly what each needs, whether enough quotes have a reported outcome, how often your guardrails held prices back, and approvals waiting or about to expire. Each finding states its numbers and names the call that would act on it; nothing is changed. Free, and computed without an AI model. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

See the multi-step pricing pipelines Last Price publishes and the stages they are built from: for each reference pipeline its name, what it is for, its topology, latency and cost ceilings, the consent it needs and the trust zones it may run in, and the stage catalogue with each stage's layer and tags. To run one without a key, use run_reference_pipeline once it is switched on (until then it answers 501 pipeline_execution_unavailable rather than a simulated price). To price an item from photos use price_from_capture; to price from numbers use compute_price, or run_pricing_chain for a chain you define. Public: needs no credential.

Ask Last Price what pricing inputs are missing. Start with request: {}, return its questions to the caller, then send continuation.request and answers. Prepare is free and does not compute. When ready, action compute uses the existing authenticated pricing API; configure a credential first. Never invent answers or treat a continuation as authorization.

Run a pricing chain: stages one after another, each stage's price feeding the next as current_price and its metadata carrying forward, your price guardrails applied once at the end from your own current_price. Stage kinds: function (a pricing function, with an optional fallback), clamp (holds the running price inside limits) and, where model stages are switched on for your workspace, llm (a prompt that lets a model adjust the price within max_change_pct, or only annotate it) and vision (the same, looking at a public https image_url, with image_consent true; it never analyses faces or emotions). Each stage reports its price in and out; a model stage also returns its annotation. Each function stage that prices is one metered call, each model stage that answers is one metered model call. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add an outbound webhook endpoint: Last Price sends a signed POST to the https url for each event you list. The answer carries the signing secret (whsec_...); keep it to verify deliveries. Events cover held agent calls awaiting approval, disputes, proposed price changes, a low balance, outcomes and changelog entries; the documentation lists their names, and an unknown name is refused. Send ping_webhook afterwards to check the endpoint answers. Needs the owner or admin role, and a key with no scope limits or a person's sign-in. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Delete a webhook endpoint and its delivery history. This cannot be undone: update_webhook with status inactive pauses it instead. Needs the owner or admin role, and a key with no scope limits or a person's sign-in. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List recent delivery attempts across your workspace's webhook endpoints, newest first: the event, the status your endpoint answered with and when. Use it to find an endpoint that is failing. Needs a key with no scope limits or a person's sign-in. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a webhook endpoint: its url, the events it gets, or switch it off and on with status. Only the fields you send change; events replaces the whole list. Needs the owner or admin role, and a key with no scope limits or a person's sign-in. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the latest profiling report for a model on the AITune sidecar: measured latency, throughput and memory per backend, so you can choose how to serve it. Pass the model name as model. Read-only; it does not start a run. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the AITune sidecar's current GPU and CPU load: utilisation, memory and temperature. Pass history true to get the readings over the last duration_minutes (1 to 1440, default 60) instead. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the inference backends the AITune sidecar offers your workspace and the state of each one: which are available, which are loaded and why one is not. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the latest weekly brief the pricing analyst wrote for your workspace: short claims, each citing the findings it rests on (every number checked against them), the findings themselves, and the proposals it recorded as pending approvals, each with the exact call that would apply it. The analyst never applies anything: whoever approves sends that call. brief is null before the first one. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read whether the pricing analyst writes your workspace a brief, how often, whether a written brief may be paid from your Last Price balance and up to what monthly cap, whether the brief is switched on for your workspace (released), the funding terms (with the x402 price of one question), and whether the commerce cycle runs on a schedule, how often, and what its latest run drafted. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change the pricing analyst settings for your workspace: turn the brief on or off, choose weekly or nightly, choose whether a written brief may be paid from your Last Price balance, with a monthly cap, and schedule the commerce cycle (daily or weekly at 03:00 UTC), which only drafts price proposals for approval and never pushes a price. Only the fields sent change. Paying from the balance is never on unless you turn it on, and it needs a cap. Refused until the brief is switched on for your workspace. Needs a Last Price credential with routing write scope (and commerce proposal draft scope for the cycle fields); from the dashboard, an owner or admin. The two balance fields are the owner's choice: the agent that owns the workspace, a credential with billing write scope, or the owner on the dashboard. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Approve or reject an action held for approval. Approving lets whoever asked repeat the same request once; rejecting keeps it held back for good. Deciding is for the workspace owner: a person, or the owner's own key (made without scope limits and not bound to an agent). An agent never decides its own request, and an agent-bound key or token cannot decide at all. The audit log records who decided. Needs a Last Price credential with the commerce proposal approve scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Approve or reject a learned pricing change waiting for approval (approve mode). Approving puts its estimate in force for that product, within your price guardrails; rejecting keeps the one in force, and the same estimate is not asked about again. change_id is the id from list_learned_price_changes or the webhook that announced the change. Needs a Last Price credential with routing write scope, or the key of the agent that registered an unclaimed workspace, which owns it.

Approve or reject one mapping Rosetta held back, by id from list_rosetta_review. Pass action approve or reject, and reviewer to say who decided, otherwise the workspace is recorded. A decision is final: an item already decided answers 409. An agent or key that queued the item cannot decide it: that answers 403, and a person or a different agent or key decides. It sends the review-resolved webhook to the workspace's endpoints. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Open a payment dispute: pass payment_id and amount, and optionally currency (default USD), customer_id, reason, status (default open) and metadata. Workspace owners and admins are emailed and subscribed endpoints get dispute.opened. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one payment dispute: its payment, customer, amount, status and reason. Pass dispute_id. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change a payment dispute: pass dispute_id and at least one of status, reason (null clears it) and metadata. Move it to under review while you look into it and to resolved or rejected when you have decided. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Create a hosted pricing model, with no version yet: add one with train_hosted_model or upload_hosted_model_version. A demand model outputs the chance of a sale and its price sensitivity, and the optimizer prices from that; a price model outputs a price, or a ratio of the current price. Names are unique in a workspace (409 when the name is taken). Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one hosted pricing model and its versions, newest first: each version's number, source (trained or uploaded), status (candidate, active or retired), size, input spec, training metrics and ONNX operators. The ONNX file itself is downloaded from GET /api/hosted-models/{model_id}/versions/{version}, not through this tool. Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's hosted pricing models: models Last Price stores and runs for you, trained here on your quote outcomes or uploaded as ONNX. Each one has its id, name, kind (demand or price), active and latest version, and whether it retrains and promotes itself nightly. The answer also gives the limits, the ONNX operators the hosted runtime runs and the request fields a model can read. A pricing function of the ML model type runs a model when its inference config is {"provider": "last-price", "model": "<model id>"}. While hosted models (the hosted-pricing-models release) are not switched on for your workspace, this answers released: false with no models, and every other hosted model tool answers 404 not_released. Needs a Last Price credential with function read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your balance of data-exchange tokens: what you hold, what you have earned by contributing price data and what you have spent reading the shared pool. Pass history true to also get the latest token movements, with limit to say how many (up to 100). Free to call. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the price data points your workspace has contributed to the shared data exchange, newest first: each one's vertical, source, product, price, currency, quality score, status and the tokens it earned. Filter by status or vertical and page with limit and offset. Free to call. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read price data other workspaces have shared in the data exchange: the newest data points, optionally for one vertical, with how many contributors back each and how fresh it is. Each query spends 5 tokens; below 5 tokens it is refused with your balance, and you earn tokens with contribute_price_data. Page with limit and offset. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Reject a drafted price proposal. A reason is required and kept in the audit trail. proposal_id is the id from list_commerce_proposals. Needs a Last Price credential with commerce proposal reject scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Reject one of your workspace's Forge candidates: it stops climbing the promotion ladder and keeps its evidence, with your reason added. candidate_id is an id from get_forge_status; a candidate already rejected, retired or promoted cannot be. Needs a Last Price credential with routing write scope; from the dashboard, an owner or admin. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Reject a payout run that is awaiting approval: nothing is paid and the ledger stays as it was. The requester may reject their own request to withdraw it. 409 when the run is not awaiting approval. Answers 404 while payout runs are not switched on for your workspace (list_payout_runs says so in execution.enabled). Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the spend policies your workspace's buyer agents spend under (the most per purchase, a daily cap in UTC days, when a person approves first, which sellers and categories), the defaults a save fills in, and what today's reservations hold. An agent key sees its own policy and the workspace default. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read a session: whether it is open, expired or closed, its maximum, what it has drawn and what remains, and its draws, newest first, each drawn, unknown or returned. Use it to resume a run, or to find a draw to settle. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Save a spend policy whole: agent_id for one agent, or leave it out for the workspace default every other agent spends under. An omitted field takes its default, so read get_spend_policy first and send every rule you want to keep. An agent's own key cannot change the rules that bind it: use a workspace-wide key. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add a person who already has a Last Price account to your workspace with a role. Only an owner can grant owner. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the people in your workspace and their roles. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Remove a person from your workspace. The last owner cannot be removed. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Total your workspace's priced calls over a period, this calendar month by default: requests, units, compute time, cost, cached and prepaid calls, and the part of this month's cost still to be billed. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

See your usage grouped by pricing function: calls, spend and outcomes for each function over a period. Pass start_date and end_date to choose the period, and group_by function, the only grouping there is. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's priced calls, newest first: each one's id (what report_outcome takes to report it), function, cost, the price given and the inputs it was given for, and who sent it. Pass buyer_agent verified for only the calls whose buying agent proved who it was with an AgentID token. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your email alert settings for your workspace: for each alert type, whether it is on and whether it comes right away or in one daily summary, whether your role gets alerts at all, and whether alert email is switched on. The agent that owns an unclaimed workspace reads its own settings. Needs a Last Price credential with notifications read scope.

Turn email alert types on or off, or choose right away or one daily summary, for yourself in your workspace. Send preferences, delivery or both, naming at least one alert type; the types are approval requested, dispute opened, webhook failing, payout update and outcomes needed. A caller that gets no alerts is refused. Needs a Last Price credential with notifications write scope; the agent that owns an unclaimed workspace needs none.

Approve a drafted price proposal so it can be pushed to the store. proposal_id is the id from list_commerce_proposals. Deciding is for the workspace owner, a person or an agent the owner has trusted with the commerce proposal approve scope; the audit trail records who decided. Approving does not push the price: use execute_commerce_proposals. Needs a Last Price credential with commerce proposal approve scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Approve a payout run that is awaiting approval, and pay it: one Stripe Connect transfer per connected account, each with an idempotency key so a retry never pays twice. Never by the requester: whoever requested the run (the same API key or agent, or the same person through another of their keys, their sign-in or an agent they created) is refused with 403, so a run your own credential requested needs another person, or an agent a different person created, to approve it. Refused with nothing paid: 503 while Stripe is not ready for payouts, 409 when the run is not awaiting approval or the ledger changed since the request (the run becomes stale; request it again). Payouts run in Stripe test mode, so no real money moves until Last Price switches live payouts on. Answers 404 while payout runs are not switched on for your workspace (list_payout_runs says so in execution.enabled). Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your workspace's prepaid balance and billing settings: the balance in USDC, whether balance billing and outcome pricing are on, the auto top-up offer, the latest ledger rows and the terms. Needs a Last Price credential with price compute scope.

Change your workspace's billing settings. Only the settings you send change. outcome_pricing turns on paying in full only when a price is used: a rejection reported with report_outcome within its window gives part back. balance_billing makes every compute call draw on the prepaid balance, and a call the balance cannot cover is refused. auto_topup is an offer, not a charge: below the threshold, results carry a top-up hint and nothing is paid automatically. A self-registered agent workspace cannot change outcome_pricing or balance_billing until it is claimed. Needs a Last Price credential with price compute scope; a person also needs the owner, admin or billing role.

Read buyer-aware pricing for your workspace: models learned nightly from your own quotes (a contextual bandit and a boosted demand model, plus a hosted model if you promoted one) that price by the kind of buyer, such as agents versus people and the sales channel. Shows the mode (shadow logs what each model would charge; live lets the chosen model price), each model with its elasticity per kind of buyer, and the last 30 days: how often each model priced, how its price compared with the price quoted, and acceptance of live-priced quotes against the rest. Needs a Last Price credential with routing read scope.

Set buyer-aware pricing for your workspace: the mode (off, shadow or live), which model prices in live mode, and which request fields the models may read. Live changes the prices your buyers are quoted, always inside the exploration band, never below cost and inside your price guardrails. A field left out keeps its saved value; null goes back to the default. Needs a Last Price credential with routing write scope; from the dashboard, an owner or admin.

Stop a customer's credit bundle subscription from renewing. The customer keeps the credits of the period they are in, and invoices already written stay. Cancelling one already cancelled changes nothing. Early access. Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Cancel a UCP checkout session: pass checkout_id. A completed session cannot be canceled, and canceling one that is already canceled changes nothing. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add to your workspace's prepaid balance by card, when no crypto wallet is at hand to sign an x402 payment. amount is in US dollars with whole cents, such as "25". Nothing is charged by this call: it returns a checkout link, a card payment page for exactly that amount, and the top-up id. Give the link to the person who runs you; once they pay, the balance is credited one USDC per dollar. Poll get_card_topup with the top-up id until its status is paid. Not every workspace has card top-ups yet: a refusal lists the other ways to pay. Needs a Last Price credential with the price:compute scope.

Read one card top-up of your workspace by topup_id: pending (with its checkout link), paid (the balance holds it), expired (the payment page lapsed unpaid) or failed, with the amount in US dollars and the USDC credited. Needs a Last Price credential with the price:compute scope.

Read the channel rates saved for your workspace: what each sales channel, such as a shopping agent or an agent marketplace, keeps of a sale, and how much of that cut is added to the price. released says whether channel pricing is on for your workspace; rates are saved either way and apply only while it is on. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Save the channel rates for your workspace. A price request that names a saved channel (the channel argument of compute_price) is raised so you keep the same amount after the channel's cut. Your price guardrails still hold the raised price. This replaces the whole list: a channel left out is removed, so read get_channel_rates first and send every channel you want to keep. An empty list removes them all. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Compute a price for a product/context via the Last Price Pricing Compute Network. Returns the computed price, the function that produced it, token metering/cost, and a `trace` listing each stage the request passed through (cache, route, execute, fallback, constrain, meter). For a competitor offer, put competitor_price, competitor_currency and competitive_action in metadata, then supply min_price or unit_cost with target_margin_pct. Missing business inputs return an error naming them. To pay for this one call with x402 instead of a key or a balance, pass payment: a signed payment for the price it asks (call it without payment to read what it asks). Where quote expiry is switched on for the workspace, the result carries valid_until (RFC 3339): quote or charge the price only before then, and compute again after.

Price up to 100 requests in one call. Each item in requests is the same request compute_price takes: a context with a three-letter currency and optionally a product, current price, segment, geo and metadata, plus an optional function_id, routing preference, constraints and options. Every item is one metered call, drawn together from your prepaid balance, all or nothing: a balance short of the whole batch charges nothing. An item that does not price comes back as an error in its place and is given back. Send the same idempotency_key to retry safely: a repeat answers from the first answer and re-runs only the items that did not price. Needs a Last Price credential with batch price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Share one observed price with the data exchange and earn 10 tokens. The data point joins the shared pool that other workspaces can read, so send only prices that are public. The same source, product and price within 24 hours is refused as a duplicate and earns nothing. Send source_url, product_name, price and a vertical such as saas. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Share up to 100 observed prices with the data exchange in one call, 10 tokens for each one accepted. Each item is the same data point contribute_price_data takes. The data joins the shared pool other workspaces can read, so send only public prices. An item that repeats a source, product and price from the last 24 hours is reported as a duplicate, earns nothing and does not stop the rest. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

See what model calls cost your workspace over a period (this month so far by default): totals, how much ran on your own provider key and how much on the platform's, and a daily series. Pass start_date and end_date to choose the period. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the individual model calls behind get_llm_usage, newest first: what each was for, its provider and model, tokens and cost. Filter by operation and by start_date and end_date, and page with limit and offset. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Open the Last Price integration code (the files generate_monetization_code writes) as a pull request in one of the workspace's own GitHub repositories, through the installed Last Price GitHub App. Commits to a new branch (last-price/billing-setup unless branch is given) and opens a pull request against base or the default branch; never merges, and refuses a branch that exists. Early access. Needs a Last Price credential with billing write scope and the App installed (get_github_app_connection). Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Before a run of small paid calls to one seller (a stream of x402 calls at a cent each, say), open one budget for the run instead of checking every call. Your owner's spend policy judges the session like a purchase of max_amount: allow holds that maximum against today's cap and returns reservation.id, the session id; ask means a person approves the budget first, then send the same request again; deny means do not start. Then call draw_session_spend right before paying each call, and close_spend_session when done, which gives back what you did not draw. A session left open gives its remainder back when it expires. Only where the workspace has sessions switched on (else an error with code not_released: use check_purchase per purchase). Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Record a payment against a customer: pass customer_id and amount, and optionally invoice_id, currency (default USD), status (pending, completed or refunded; default pending), payment_method and metadata. It records the payment in Last Price; it does not charge anyone. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one payment: its invoice, customer, amount, currency, status and method. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Try an offer against one of your own products and see the answer a buyer would get (accept, counter or reject), with the limits behind it. Nothing is recorded and nobody is bound, and it works while offers are off, so you can check your terms first. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Try a page and selectors without saving a job: fetch the page once and answer the prices the selectors find, with the page's HTTP status. Nothing is stored. Hosted scraping is behind a release flag: until it is on for your workspace this answers 501 hosted_scraping_not_enabled. Runs honour robots.txt and fetch only public https pages. Needs a Last Price credential with the commerce:configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's products with the category confirmed or suggested for each, the category tree, and per category how many outcomes your own products in it have toward the 30 an estimate needs (an inferred outcome counts half). A suggestion comes from the product's name and is not stored until confirmed with set_product_category. Only your workspace's own data is read or shown. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Confirm or change the category of one of your workspace's products: product_id is the product id your quotes send (or a store item's SKU), category_id is an id from the tree list_product_categories returns, at any level. Replaces any earlier category for that product and answers with the same body as list_product_categories. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Before you pay for something, ask whether your owner's spend policy lets you pay this price to this seller. Works for any purchase, whatever wallet or checkout you pay with. Returns a decision (allow, deny or ask), a reason code and a reason. allow comes with a reservation: the amount is held against today's cap, so make the purchase, then call settle_purchase with outcome paid (and the amount paid) or failed. ask means a person approves first; once they have, send the same check again. deny means do not buy. With include_fair_price, or when the policy asks for it, the price is also judged by verify_price and its verdict and band come back with the answer. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one buyer intent across every check made under its intent_id: the intent as recorded (source, merchant, maximum, currency, expiry, the evidence hash, and verified, false until Last Price can check the evidence), how many checks were allowed, denied or asked about, and how much of the maximum is held, spent and left. Use it before the next purchase under the same intent. An agent key sees only its own checks. Only where the workspace has intents switched on (else an error with code not_released). Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Get a price for registering a domain for a storefront, held for 15 minutes. A quote costs nothing and registers nothing: only the workspace owner can buy it, in the dashboard. Only where domain search is switched on (else an error with code not_released). Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read a buyer's reply to a quote you sent: does it accept, say the price is too high, counter, ask a question, or decline? Send text, with quoted_price and currency when known. Returns accept, too_high, counter, question, decline or unclear, confidence, option probabilities (null for keyword rules), and counter_price when found. The existing decision model reads the reply, falling back to keyword rules when unavailable; source says model or rules. The reply may be sent to the model provider and the evaluation may incur model usage cost. Last Price does not retain the reply text; analytics records the decision without that text. This call does not accept a deal or change a price. Answers 404 not_released while unavailable for the workspace. Needs a Last Price credential with pcn:routing:read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Report whether a price from compute_price was used: once the buyer has accepted or turned down a price, report it. Pass receipt.id from that result as usage_event_id, or omit it to report the last price compute_price returned on this connection or tools instance, once (the hosted MCP endpoint remembers nothing, so pass it there). Outcomes are what later routing and confidence learn from. With outcome pricing on, a rejection within the call's outcome window gives back part of what it cost; the result says what was refunded. Needs a Last Price credential. Report only what actually happened. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Tell Last Price a price or an answer is wrong, or send an idea, on the person's behalf: when they say a price from price_from_capture is off, it named the wrong item, something did not work, or they have a suggestion. reason is price_wrong, wrong_item, broken, idea or other; note is what they said, in their words (up to 2000 characters). For a price, send its check_id (from price_from_capture or list_price_checks), item_name, computed_price and the price they expected in expected_price with its currency, so the team can look at that exact answer. Returns the report's id. It changes no price; the team reads every report. At most 20 reports an hour; past that it answers 429. Until reports are switched on for your workspace it answers 404 not_released. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Check that the Rosetta translator is up: its status, the canonical schemas it serves and the time on its clock. Public: needs no credential.

List the mappings Rosetta held back for a person or agent to approve: each one's source, proposed canonical field, confidence and status. Pass status pending, approved or rejected to filter; with none you get all of them. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Close the reservation an allowed check_purchase gave you, once: outcome paid when the purchase went through (send amount when you paid less than reserved; never more), or failed when it did not, which gives the amount back to today's budget. When you cannot tell (the payment timed out or the answer was unreadable), send outcome unknown: the amount stays held, failed is then refused, and reconcile_purchase closes it once you know. A reservation is never released by time alone, so always settle it. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Say what happened to a call you drew for with draw_session_spend. outcome failed: the payment did not go through, so the draw goes back to the session. outcome unknown: you cannot tell (a timeout, an unreadable answer), so the draw keeps counting until it is reconciled. Then, from what you checked, outcome paid (amount when less than drawn) or not paid, each with a note. Not paid gives budget back, so only the workspace's owner may send it: a workspace-wide key with routing write scope, never an agent's own key. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Pull the catalog from one linked store now. connector_id is the id from list_commerce_connectors. Needs a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Pull recent orders from one linked store, for the store sales view. since limits it to orders after that time; the default is since the last sync, or 60 days on the first. Platforms that cannot read orders answer an error. Needs a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Dry-run a commerce pricing policy against an item and competitor observations you supply, and see the price it would propose and why. Nothing is saved. Needs a Last Price credential with commerce proposal draft scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Test-run one pricing function with sample data and see the price, explanation, confidence and alternatives it returns, without publishing it or touching live traffic. Your own draft functions can be tested here; a function that runs on a model provider can be tested only by its owner. Send context (for example the current price), constraints or options to override the sample. Needs a Last Price credential with function test scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your workspace settings: company name, address, email, phone, website and description, tax id, default currency, payment terms, invoice prefix and footer, whether tax is on, the tax registrations and the sales playbook. Model keys are never shown. Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Change your workspace settings. Only the fields you send change: company details, tax id, default currency, payment terms in days, invoice prefix and footer, tax on or off, tax registrations (null clears them) and the sales playbook (null resets it). Model keys are managed in the dashboard, never here. Needs a Last Price credential with workspace settings write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Take the seller's standing counter: the negotiation closes as accepted at that price. This commits the buyer to the price, so call it only when you mean to buy at it. A counter past its time, a closed negotiation, or a counter the seller can no longer allow answers with a conflict and binds nothing. Needs the negotiation id and the buyer token. Public: needs no credential.

Activate a draft order: pass order_id. It answers 404 when the order is missing or is no longer a draft. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

How should traffic be split next between price variants? Send the trials and conversions of two to ten variants and get each one's share of the next traffic by Thompson sampling: its chance of being best, with a floor so none is starved (min_weight). Exact by default; in Monte Carlo mode it samples draws times, reproducibly for a given seed. Billed as one call to the allocator function. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Approve and apply a proposal the pricing analyst made (an analyst.* approval, listed in get_analyst_brief and list_approvals). Its stored call runs with your own credential, so the target route checks your role and scopes; only when it succeeds is the proposal approved by you and marked applied. A refusal comes back unchanged and leaves the proposal pending. It runs once even when two applies race. Only the call the action allows runs; anything else is refused. A person, a workspace key, or the agent that owns the workspace may apply; no other agent may, and nobody applies their own request. A proposal already applied runs nothing again and says it was already applied. Needs a Last Price credential with routing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read one approval: the held action, who asked, its status, the reason given and when it was decided. approval_id is the id from list_approvals or the notification that announced it. Needs a Last Price credential with audit read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the actions held for approval in your workspace, newest first: what was asked, who asked (agent or key), its status (pending, approved, rejected or expired) and when it expires. status pending lists what waits for a decision; pass its id to decide_approval. Needs a Last Price credential with audit read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Ask the pricing analyst one question about your workspace's pricing, in plain words, and get short claims that each cite the findings or estimates they rest on: every number is checked against them, and a claim with a number that is not is dropped. It refuses to forecast, to state a price or to answer from anything but your own records. At most 500 characters and 30 questions an hour. Paid like the brief (your own model key, the monthly allowance, or your balance if you opted in, which only a credential with routing write or billing write may spend); when nothing pays, the answer lists the closest findings plus the x402 price and requirements for one written answer (0.02 USDC): sign them and call again with payment, which is settled only when a written answer is delivered within this call, never for a refusal. Changes no setting and no price. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the workspace audit log, newest first: who did what and when, including who decided each approval. Filter by action, subject_kind and subject_id, agent_id or since; pass the returned cursor to page on. The team's own rows are for owners and admins. Needs a Last Price credential with audit read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Browse the public marketplace catalog of pricing functions.

Buy a day pass for your workspace: extra compute calls for 24 hours, paid with one x402 payment signed by your own wallet. Called without payment it spends nothing and returns the payment requirements (price, recipient, network, asset) to sign. Sign them, then call again with payment set to the base64 payment (the value of the X-PAYMENT or PAYMENT-SIGNATURE header). Only a self-registered agent workspace may buy one; list_day_passes shows the offer and your passes. Needs a Last Price credential with the price:compute scope.

Preview the tax an invoice or order would get from the registrations saved on Settings, Tax (US nexus, EU VAT OSS, other VAT and GST), without saving anything: the subtotal, each jurisdiction's rate and amount, the total, and why (calculated, not registered, reverse charge, exempt). US rates are state-level only unless a registration overrides them. Early access: answers that it is not released until tax calculation is switched on for the workspace. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the canonical schemas the Rosetta translator maps any vendor's data onto: product, offer, observation, match and action, with each one's id and fields. Use it to learn which canonical targets exist before you map a source. Public: needs no credential.

Change a team member's role. The last owner cannot be demoted. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

What changed in Last Price: the newest release notes, optionally for one feature, written for agents as well as people. Pass feature (a tag such as billing, webhooks, mcp, agent-payments, approvals) to follow one part of the product, and since (YYYY-MM-DD, for example the date you last checked) to see only newer notes. Each note has its date, title, summary, category, feature tags, a link to the full note and, when there is one, the docs section and app screen it is about. Public: needs no credential. Check it at the start of a session and before changing integration code.

Close a session when its run of calls is done, once: what you drew counts as spent, and returned says how much of the maximum went back to today's cap. Close as soon as you are done rather than letting it lapse, so the rest of the budget is free for other purchases at once. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Complete a UCP checkout session: pass checkout_id. Payment processing is not configured yet, so an open session answers 501 until a payment provider is set up; a session that is already completed is returned as it is. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Call right before you pay for a purchase check_purchase allowed. If the workspace's owner changed the spend policy since the purchase was approved (a lower maximum, a lower daily cap, a blocked seller), it is checked again under the rules as they stand now. confirmed true: pay now. An error saying the policy changed: do not pay; the hold was released, so check the purchase again. Only while the workspace has confirming switched on (the reservation then names confirm). Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the apps you connected to Last Price by signing in (Claude, ChatGPT and other MCP clients), newest first: each one's id, name, the host it returns to, the workspace, whether it has full access or which scopes, and when it was connected and last used. this_app marks the connection making this call. Read-only. Needs a credential that names a person: signing in to Last Price from this MCP client, or a person token. An API key names a workspace, not a person, and gets 403. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the contacts in your workspace, newest first, or only one customer's with customer_id. Page with limit and offset. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Total the costs recorded in your workspace over a period, grouped by day (the default), week, month, agent, customer or type: count, total, average, smallest and largest amount for each group and currency, and overall totals. Pass start_date and end_date to choose the period. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the costs recorded in your workspace, newest first: what each was for, its amount, currency and the agent or customer it belongs to. Filter by customer_id and by start_date and end_date, and page with limit and offset. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's prepaid credit bundles for the customers you bill, newest first: each one's id, customer, amount bought, balance left, currency and expiry. Pass customer_id for one customer. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the customers in your workspace, newest first. Page with limit and offset. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the settings behind simulate_agent_cut: whether the cut advisor is released for your workspace, the defaults it applies and the limits on each input. Free to call; read it before simulate_agent_cut to see what it will accept. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your workspace's day passes, newest first: for each, the calls left and when it ends, plus the total calls left and what a new pass costs now. A day pass is extra compute calls for 24 hours that a self-registered agent workspace buys with one x402 payment: buy_day_pass buys one. Needs a Last Price credential with the price:compute scope.

List the demo apps Last Price ships, each with its name, description, the experiment it runs and, once the demo workspace is seeded, that experiment's status, views and conversions. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

While the person is still typing or talking about an item, see what it sounds like so far: send the words so far in text (they may stop mid-word) and get a sheet with the likely name, brand, model and category, a headline and short description, up to 4 details, and certainty (0 to 1), plus up to 6 freely licensed pictures of that kind of item from Openverse and Wikimedia Commons, each with its creator, license and source link to credit. settled is true once certainty reaches 0.75: a good moment to ask the person whether that is their item, then price it with price_from_capture. side (selling or buying) shapes the headline; pictures false skips the picture search. It never gives a price. A cache miss makes one small model call, recorded as model usage, and refreshes the cached answer. Repeats may reuse that answer for ten minutes on the same server instance. Until it is switched on for your workspace it answers 404 not_released. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Disconnect an app you connected by signing in: its sign-in stops working at once, and it must ask you to sign in again to come back. Pass an id from list_connected_apps. A connection with less than full access can disconnect only itself; the dashboard can disconnect any, under Profile, Sessions, Connected apps. Cannot be undone. Needs a credential that names a person: signing in to Last Price from this MCP client, or a person token. An API key names a workspace, not a person, and gets 403. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Find offers you can call for a task, ranked: describe what you are trying to do in task and get a short list of priced offers (marketplace pricing functions and paid x402 services), each with how to call it, its price per call, where that price sits against what paid x402 services list, and why it is in the list. Places marked ranked are earned on measured results (the Elo Index) and relevance; places marked explore are new offers not yet measured, about a fifth of the list by default. Nobody pays for a place. Narrow with category and max_price (USD per call). When you call an offer, send the feed reference it carries as the x-lp-feed-ref header. Public: needs no credential, limited per address. Until it is switched on it answers not released.

List the payment disputes in your workspace, newest first. Filter by status (open, under review, resolved or rejected) and page with limit and offset. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Right before you pay for one call in a session open_spend_session opened, draw the call's price from it. drawn true: pay for the call now. An error means do not pay for this call: the draws would pass the session's maximum (remaining says what is left), this one call costs more than the policy allows per purchase, your owner changed the policy and the session was closed (open a new one if it still allows), or the session is closed or expired. If the call then fails, settle_session_draw with outcome failed gives the draw back. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Estimate what a task would cost to do by people across countries: pass task_description and countries (names or ISO codes), and optionally currency (default EUR), complexity (low, medium or high) and estimated_time_minutes. It makes a model call, billed to your provider key when you set one and to the platform's otherwise. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Push every approved price proposal to its connected store now. This changes live prices on the store and cannot be undone from here. Needs a Last Price credential with commerce execute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's price experiments: each one's key, name, status, variants (arms) and target sample size. Pass status to see only drafts, active, paused or completed ones. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read Forge for your workspace: the pricing models the nightly job trained on your own reported quotes (for the workspace and its busiest products, the model and data window it chose and how often the market drifted), each with the rung it reached on the promotion ladder (bench, then replay on your logged quotes) and every gate's evidence; the recent runs; and the pricing experts the self-recoding coder wrote and tested on the test bench, without their source. Nothing here changes a price. Not available until Forge is switched on for your workspace. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Freeze a mapping plan into a pinned adapter: every mapping is stamped as frozen so the same input maps the same way every time with no model call. Pass plan from plan_rosetta_mapping. Returns the adapter; nothing is stored. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the frontier price model: one network trained on millions of simulated markets across every vertical, pricing topology, unit, buyer and channel, run inside Last Price on every request with no GPU. Shows which version runs (a stored one, or the seed that ships with Last Price), how much profit it gives up on the eval's one-look markets (lower is better) and the stored versions. Answers released: false while it is not switched on for your workspace. Read only. Needs a Last Price credential with routing read scope.

List the pricing functions registered for the authenticated tenant.

Write the Last Price integration code for an app (Next.js, Express or FastAPI): a client that records signals, prices calls, creates customers and bills them through Stripe, plus an example, as files and one patch for git apply. Writes nothing anywhere. Early access. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Whether the workspace can open its billing code as a pull request: if that is switched on, whether the Last Price GitHub App is set up on this deployment, and which GitHub account the workspace installed it on. A person installs the App from the Monetization page, Automated tab. Early access. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Give a customer an active credit bundle: its credits are added to their balance and, unless create_invoice is false, a draft invoice for its price is made. Unlimited bundles cannot be granted as a balance. Early access. Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the newest messages in your own agent inbox: the inbox of the agent your key or token is bound to, and no other. Answers live from the mail provider when it is reachable, otherwise from the mail Last Price stored (source says which). Needs an agent key, or a token exchanged from one.

Propose a feature contract from sample pricing requests: nested objects are flattened by path, lists reduced to counts, sums, maxima and has-value flags, numbers binned, and fields that identify someone left out, each with the reason. Nothing is stored; save the result with set_feature_contract. Needs a Last Price credential with routing read scope.

See which model providers your workspace has connected for pricing functions that run on a model, and whether key storage is available. Status only: the keys are write-only and never returned. Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Onboard a merchant feed with one call: send payload and canonical_target and Rosetta fingerprints the shape, reuses a frozen adapter when it has one and otherwise plans, freezes or queues the mapping by confidence. The status says stable, provisional or needs review. Pass samples, up to a few more payloads, to improve the guess, and merchant_id to label the integration in the audit trail. The first call for a new shape provisions and stores an adapter and may queue a review. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List the invitations still waiting to be accepted: email, role and when each was sent. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Invite someone by email to join your workspace with a role. The invitation link is emailed to them, never returned. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's invoices, newest first: each one's id, customer, number, status, amount, currency and due date. Pass customer_id for one customer. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Issue one of your invoices through your connected Stripe account so the customer pays on Stripe's page: returns the hosted invoice URL. send true also asks Stripe to email it. Safe to retry; an invoice is issued once. Early access. Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Name a price for a seller's product and get the answer: accept, counter or reject, with the price and the reason. The first offer opens a negotiation and returns a buyer token, once: keep it. To make the next offer in the same negotiation, pass negotiation_id and buyer_token too. buyer_ref is an optional opaque reference for the seller and never a name or email. The seller's floor is never breached or shown. Public: needs no credential, and it is limited per address and by the rounds the seller allows.

Mark your workspace's notifications read for this reader only (your agent, or your key), up to read_through (default now). Send the creation time of the newest item you handled so anything newer stays unread. Needs a Last Price credential with notifications write scope; the agent that owns the workspace needs none.

Read your own negotiation with a seller: its status, the rounds used and left, the standing counter, the agreed price and the history. Needs the negotiation id and the buyer token the negotiation opened with, not an account. A wrong token and a missing negotiation answer the same not found. Public: needs no credential.

Your workspace's negotiations, newest first: what a buyer sees plus the floor and asking price each one opened with. Use it to honour an accepted price at checkout: find the negotiation and charge its agreed price. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Turn a vendor's response into the canonical shape using a plan from plan_rosetta_mapping: returns the canonical record, the fields that were missing, the lossy conversions and what passed through unmapped. Pass plan and vendor_response. Read-only. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's notifications, newest first, with the unread count: approval requests, disputes, price proposals, email to agent inboxes and, for the agent that owns the workspace, failed webhook deliveries. Pass the next cursor a page returns back as cursor for the next page. Unread is per reader: an agent has one read state for all its keys and tokens, a plain key has its own. Needs a Last Price credential with notifications read scope; the agent that owns the workspace needs none.

List the orders in your workspace, newest first, or only one customer's with customer_id. Page with limit and offset. Read-only. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read your workspace's outcome pricing: whether it is on, its terms, counts of open, accepted and rejected windows with the total refunded, and the windows themselves, newest first. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's payments, newest first: each one's id, invoice, customer, amount, currency, status and method. Pass customer_id for one customer, or status for pending, completed or refunded payments. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Send one signed webhook.test event to an active endpoint now and record the result as a delivery, so you can check it receives and verifies events. Read the outcome with list_webhook_deliveries. Needs a key with no scope limits or a person's sign-in. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Ask Rosetta how a source schema maps onto a canonical one: for each source field the target field, the transform, a confidence and where the mapping came from, with a plan confidence and tier. Pass source_schema (an id and its fields, each a path and type) and canonical_schema (the id of a built-in schema from list_canonical_schemas, or a whole schema). A plan below the confidence bar is queued for review and the answer says so; list_rosetta_review shows the queue. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Try a hosted model on a request context before (or after) promoting a version: the price it would give, and what the model said (a demand model's chance of a sale and elasticity, or a price model's output). Uses the active version unless version names another, and 409 when there is none. Nothing is metered or logged as a quote. Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function test scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Make a version of a hosted model the active one: the next call to every function that runs this model uses it, with no change to callers. The version that was active is retired and stays available to roll back to. Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Per-prompt-class quality benchmarks across pricing functions and providers: for each kind of request (no text, code, extraction or JSON, multilingual, long form, short factual, general), how good (quality), how fast (p50 and p95 latency) and how cheap (mean cost) each function or provider is. Every cell names its source (simulated bench, recorded bench, or your workspace's own routed calls), its quality metric and its sample size; sources are never mixed. Your workspace's cells appear once a cell has min_events routed calls. Only aggregates: no prompt text is stored. Use it to choose a routing preference or function per kind of request. Needs a Last Price credential with routing read scope; answers 404 until prompt-class benchmarks are on for your workspace. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Add one price arm to an existing experiment: pass experiment_key and the price, optionally label (otherwise the next variant_N is used) and metadata. The experiment must split traffic evenly and have room for another arm (ten at most); one whose arms carry weights refuses, so the author has to say how traffic is reshared. This changes the experiment, so a running one starts serving the new price to its share of buyers. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the public pricing-function leaderboard: the functions the community uses most, ranked by distinct outside consumers, with their rating. Pass window as 7d, 30d, 90d or all (default all). Public: needs no credential, limited per address.

Get the receipt for one of your workspace's priced calls, by its usage event id (the id list_usage_events returns and report_outcome takes): what was priced, by which function and agent, when, the amount, how it was paid, and the outcome if one was reported. Receipts are made only when you ask, never sent for every call. For CSV or a printable page, call GET /api/receipts/{id} with format=csv or format=html. Needs a Last Price credential with price compute or billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Get receipts for many of your workspace's priced calls at once, as one statement with totals: name up to 50 usage event ids, or a period (this calendar month by default, at most 366 days), optionally for one function or agent. A period statement also counts, for each agent, the value signals set up in Settings, Value receipts. Receipts are made only when you ask. For CSV or a printable page, call GET /api/receipts with format=csv or format=html. Needs a Last Price credential with price compute or billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Ask Jale for the price to run next in one of your experiments: it simulates each candidate price against the experiment's results so far and returns the best one for your objective with its expected effect and how confident it is. Pass experiment_id. Optionally pass objective (revenue, conversion, profit or market share, default revenue), candidates (the prices to compare, otherwise a grid is chosen) and lookback_days. It recommends only; it changes no price. Needs a Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Close a reservation whose outcome you reported unknown with settle_purchase, once, from what you checked (the processor's record, the wallet, the seller's order). Paid counts it at the amount paid. Not paid gives the amount back to today's budget, so only the workspace's owner may say so: a workspace-wide key with routing write scope, never an agent's own key. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Record a cost in your workspace, such as a vendor or infrastructure cost, so the Value Receipt and the cost analytics count it: pass amount, and optionally currency (default USD), cost_type (default usage), agent_id, customer_id and metadata. This writes a record that is not undone by another tool, so record what was really spent. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Run a reel live and read its transcript: each step's tool, arguments, status, time and answer, the outcome in one line, and an Ed25519 signature over the transcript checkable at /.well-known/quote-keys.json when signing is configured. Every read is a fresh run on the keyless demo, so it shows what the API answers now, not a recording. It spends your own demo allowance. Public: needs no credential. Until it is switched on it answers not released.

List the reels: short recipes for real tasks done with Last Price (price a SaaS seat, check a vendor quote, find an offer for a task), with the tools each one calls. A reel is the agent-readable alternative to a demo video: read one with get_reel and it runs live. Public: needs no credential. Until it is switched on it answers not released.

Run one of the seven reference pipelines on the pricing-chain engine without a key: every number in the answer is computed. Rate limited per IP (10 per hour). Answers 501 pipeline_execution_unavailable while the public-pipeline-run flag is off. Needs context.current_price or context.unit_cost. Any stage it could not run is listed under not_run, and the rest still prices. Works without a Last Price credential; list_pricing_pipelines shows the pipelines.

Mark a payment refunded: pass payment_id, and optionally amount (up to the payment amount; the whole payment otherwise) and reason. It records the refund in Last Price, and answers 400 when the payment is already refunded. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Sign up with no key and no human: creates a sandbox workspace of your own and returns its API key (shown once), its daily limits and a claim link a person can open to take the workspace into their account. Pass name (2 to 64 characters, such as your-system/role-name), and optionally contact_email and intended_use. On the hosted MCP server this session goes on using the new key, so the tools that need a credential work at once with no header to add; elsewhere send the returned key as the x-api-key header. Public: needs no credential.

Ask what paying your marketplace ledger for a period would send, or request that payout. With dry_run true (the default) you get the report: what each connected account would be sent, and every entry skipped with the reason. Nothing moves. With dry_run false, for a period that has ended, the run waits for approval by someone other than whoever requested it: approve_payout_run refuses (403) the same API key or agent, and the same person through another of their keys, their sign-in or an agent they created. Payouts run in Stripe test mode, so no real money moves until Last Price switches live payouts on. Answers 404 while payout runs are not switched on for your workspace (list_payout_runs says so in execution.enabled). Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Send again the transfers of a partial payout run that are due for a retry (after a network error, a timeout or a Stripe outage), each with the same idempotency key as before, so Stripe never pays one twice. The amounts were approved already, so no new approval is needed. A transfer that failed for good is not retried: request a new run once the cause is fixed. 409 when nothing is due yet (the error's details say when the next retry is), 503 while Stripe is not ready. Answers 404 while payout runs are not switched on for your workspace (list_payout_runs says so in execution.enabled). Needs a Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Withdraw a pending invitation: invitation_id on a list_invitations result. Needs an API key sent as x-api-key that holds the team:admin scope, made by someone who is still an owner or admin of the workspace; a token or any other key is refused. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Make the version of a hosted model that was active before the current one active again. Answers 409 when no version was active before. Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Load a self-contained demo into your workspace: a memory store, a small catalog, competitor prices below it and an undercut policy in manual mode, so run_commerce_cycle drafts proposals you can approve. Safe to repeat; it reuses what it made. Needs a Last Price credential with commerce configure scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Email an invoice to the customer and mark it sent: pass invoice_id, and optionally to (an email address; the customer's own is used otherwise). This sends a real email and answers 404 once the invoice is already sent, so check it with get_invoice first. Needs a claimed Last Price credential with billing write scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Simulate how much of a sale to offer an agent platform (a shopping agent or agent marketplace that charges sellers a cut) if it ranks sellers partly by the cut they pay. No platform publishes such a ranking, so this is a simulation under your assumption (visibility_per_point_pct: percent more channel sales per extra point of cut), also run at half, double and zero of it. Returns the profit at each cut, the recommended cut, the cut with the smallest worst case, the break-even, and a channel rate ready for PUT /api/channel-rates. Changes nothing. Answers 404 until the cut advisor is switched on for your workspace. Needs a Last Price credential with routing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Start a profiling run for a model on the AITune sidecar: pass model, and optionally batch_sizes, measurement_steps, saturation_cutoff and include_warmup to override the defaults. It uses GPU time on the sidecar; read the finished report with get_aitune_profiling. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List your workspace's storefronts: each one's subdomain, name, whether it is published, what it lists (functions, products open to offers, tag and product filters), its own domains with their DNS records and status, and the addresses agents use (page, agent card, llms.txt, MCP). Also the limits and a suggested subdomain. A storefront is your own front door for agents at <subdomain>.store.last-price.ai or a domain you own. Only where the workspace has storefronts switched on (else an error with code not_released). Needs a Last Price credential with workspace settings read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read whether your workspace has a Stripe account connected for invoices (Connect with Stripe on the Monetization page), its account id and mode, and whether this deployment can connect one. Connecting needs a person in a browser. Early access. Needs a Last Price credential with billing read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Ask the frontier price model what it would charge for one of your products: it reads your own quotes for that product from the last 90 days (rebased onto today's price) and where the offer sits, and returns the price, the chance of a sale there and at today's price, the margin per quote when you give unit_cost, and the acceptance curve. It looks at most 10% past prices you have already quoted, inside min_price and max_price. A suggestion only: nothing is quoted, stored or learned, and no other workspace's quotes are read. Without unit_cost it maximises revenue. Answers not_released while it is not switched on for your workspace. Needs a Last Price credential with routing read scope.

Add USDC to your workspace's prepaid balance with one x402 payment signed by your own wallet. amount is in USDC, such as "25". Called without payment it spends nothing and returns the payment requirements to sign. Sign them, then call again with the same amount and payment set to the base64 payment (the value of the X-PAYMENT or PAYMENT-SIGNATURE header). The result gives the credited amount, any bonus and the new balance; get_billing_settings shows the terms. Needs a Last Price credential with the price:compute scope.

Train a new version of a demand model on your workspace's own quote outcomes (reported, or inferred from what buyers did next). A held-out fifth of the quotes scores it against one pooled demand curve, and its metrics say by how much it did better. promote never (the default) stores it as a candidate, always makes it active, and if_better makes it active only when it beats the pooled curve and the active version. Answers 422 with the number of outcomes when there are too few to train on, and 422 for a price model. Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Translate one source record into a vendor's payload in one call: Rosetta plans the mapping, compiles source_record against it and validates the result against vendor_contract (an id and the fields the vendor requires). The answer says whether the payload is ready, the plan, the payload, any skipped fields and each validation issue. Set allow_extra to let fields the contract does not list through, and extensions for vendor extensions. A plan below the confidence bar is queued for review. Needs a claimed Last Price credential. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Upload a model trained anywhere as a new version of a hosted model: the ONNX file as base64 (at most 4 MiB) and the spec that maps request fields to its inputs. It is checked before it is stored: it must parse, use only operators the hosted runtime runs (scikit-learn, XGBoost and LightGBM tree ensembles, linear models, small neural networks), take as many inputs as the spec lists, and give a finite answer of the right shape on a test row; otherwise it answers 422 naming the problem. Stored as a candidate unless promote is true. The hosted MCP endpoint (/api/mcp/rpc) takes requests of at most 64 KiB, so send a larger file with the stdio server, the tool packages or POST /api/hosted-models/{model_id}/versions. Answers 404 not_released while hosted models (the hosted-pricing-models release) are not switched on for your workspace. Needs a Last Price credential with function publish scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Use a Last Price API key you already hold (a saved file, LASTPRICE_API_KEY) in this MCP connection, when it was opened without one: pass api_key. On the hosted MCP server this session then runs as that key's agent, so the tools that need a credential work at once with no header to add; it lasts until the session ends or the key is revoked or rotated. The key is checked, never echoed back. A connection that already has a credential keeps it. Public: needs no other credential.

Is there a winner yet in a price test? Send the trials and conversions of two to ten variants and get, for each, its chance of being best, its expected loss and a 95% credible interval, and a verdict of winner, equivalent or continue. With exactly two variants, the first is the control and a sequential probability ratio test is added. Change the prior, win_probability, loss_threshold or sprt settings to be stricter or looser. Billed as one call to the significance function. Needs a Last Price credential with price compute scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

See which outside pricing engines (vendor adapters, such as Pricefx and Prisync) this deployment has switched on. Each one lists its function name, its vendor and whether it is ready; one that is not says whether the adapters are off or that adapter is not configured. Read only: it never shows a setting value. A ready adapter is priced through by naming its function when computing a price, never by automatic routing. Needs a Last Price credential with function read scope. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

List what a price verification can stand on: the verdicts it can give (fair, too high, too low or unknown) and the evidence strategies a verdict is checked against. Use it at planning time, before you call verify_price. Public: needs no credential.

Read the USDC a wallet holds on the network pay-per-call uses, from the chain, and what it covers: paid calls and day passes. address is the wallet that signs your x402 payments. Check it before buy_day_pass, top_up_balance or a paid compute_price. Nothing is signed and no money moves. Needs a Last Price credential with the price:compute scope.

List your workspace's outbound webhook endpoints: each one's id, url, events, status and signing secret (whsec_...; the secret is how you verify the x-lastprice-signature header on what it receives). Needs the owner or admin role, and a key with no scope limits or a person's sign-in. Needs a claimed workspace: a sandbox key from self-registration is refused (403) until a person claims the workspace.

Read the x402 market price band: what paid x402 services list per call in public x402 discovery catalogs, as the 10th percentile, median and 90th percentile price per call for each category and over every category, with how many services stand behind each band and the day it describes. Pass category to narrow to one, and days with it for that band per day. Use it to see what a paid call usually costs before you pay; verify_price and check_purchase use the same band. List prices only, never evidence of demand: some sellers pay themselves. Public: needs no credential, limited per address. Until it is switched on it answers not released.