Muse courier connector

Autolane’s courier connector lets an AI agent hand a curbside food order to an Autolane vehicle. The agent places the order on the store’s website in the user’s own name. An Autolane vehicle collects it at the curb and drives it to the user’s address. Muse, Meta’s agent, is the first client.

This page is the full reference for agent developers and reviewers: who can use the connector, how clients authenticate, the six tools, every response and error, payment, limits, and how Autolane handles data.

At a glance

Access requirements

People

During the pilot, access is by invitation: Autolane enables each mobile number. A number that is not enabled sees this message at the phone step, and no code is sent:

Autolane Courier isn’t available for this number yet.

If Autolane removes a number later, it loses access at its next MCP call (401) or token refresh (invalid_grant), whichever comes first.

Each person needs:

• A mobile number that receives SMS, entered with its country code. A 10-digit number typed without + is read as a US number (+1 is added).
• A store and a drop-off address inside the same Autolane service area in Austin.
• To accept the delivery terms and the text-message consent that the agent shows before it reserves a vehicle.

Clients

An agent client must support:

• MCP over Streamable HTTP.
• The OAuth 2.1 authorization code flow with PKCE S256, sending the RFC 8707 resource parameter.
• Discovery through RFC 9728 (protected resource metadata) and RFC 8414 (authorization server metadata).
• RFC 7591 dynamic client registration with a redirect URI that Autolane has allowlisted. To add a redirect URI, email support@goautolane.com.
• Showing the user the price, the terms and the consent text before the reserve.
• Taking payment for the delivery fee through the hosted Stripe Checkout link or a Stripe shared payment token.
• Placing the store order on the store’s website in the user’s own name.

What Autolane serves

• Stores. Restaurants and other prepared-food businesses with curbside pickup: restaurants, cafes, bakeries and takeout. The store must appear on Google Maps at the address given, with a phone number and opening hours, and the agent must list curbside among the store’s pickup options.
• Stores Autolane refuses, whatever the cart holds: liquor stores, pharmacies and drugstores, convenience stores, gas stations, supermarkets, grocery and food stores, markets, warehouse, discount and general stores, wholesalers, bars, pubs, breweries, wineries and night clubs, casinos, smoke shops, and entertainment venues such as karaoke bars, comedy clubs, dance halls, live music venues, bowling alleys and cinemas.
• Check-in. The vehicle cannot use a store’s own app. A store whose only check-in is its app is declined (app_only_check_in).
• Timing. Autolane offers 15-minute pickup windows from the store’s lead time up to 90 minutes ahead, inside both the store’s opening hours and Autolane’s service hours (8 AM to 8 PM, store time). It does not take orders for later than that.
• Restricted items. Never use Autolane for alcohol, tobacco, vape and nicotine products, pharmacy and prescription items, lottery, firearms and ammunition, or any order that needs an ID or an age check at pickup. Autolane screens the items on every order and will not deliver them.
• Pickup requirements. An order is not serviceable when pickup needs an ID, a name match with the person collecting, a signature or an age check (id_required, name_must_match, signature, age_restricted). Autolane never provides a pickup person’s name or a license plate. If checkout requires either and accepts nothing else, the order is not serviceable.

Authentication

Autolane’s authorization server is the MCP resource itself. Its issuer is https://mcp.goautolane.com/api/delivery-mcp, and every OAuth endpoint sits under that path. While Autolane has the connector paused, the MCP endpoint, the four OAuth endpoints and the authorization server metadata answer 404.

Step 1: get the 401

Call the MCP endpoint with no token. The WWW-Authenticate header points to the protected resource metadata.

POST /api/delivery-mcp/mcp HTTP/1.1
Host: mcp.goautolane.com
Content-Type: application/json
Accept: application/json, text/event-stream
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"example-agent","version":"1.0.0"}}}

HTTP/1.1 401 Unauthorized
Content-Type: application/json
WWW-Authenticate: Bearer error="invalid_token", error_description="No authorization provided", resource_metadata="https://mcp.goautolane.com/.well-known/oauth-protected-resource/api/delivery-mcp"
{"error":"invalid_token","error_description":"No authorization provided"}

Step 2: read the protected resource metadata (RFC 9728)

GET /.well-known/oauth-protected-resource/api/delivery-mcp HTTP/1.1
Host: mcp.goautolane.com

{
  "resource": "https://mcp.goautolane.com/api/delivery-mcp",
  "authorization_servers": ["https://mcp.goautolane.com/api/delivery-mcp"]
}

The response carries Cache-Control: max-age=3600 and allows any origin.

Step 3: read the authorization server metadata (RFC 8414)

The issuer has a path, so under RFC 8414 section 3.1 the metadata is served only at /.well-known/oauth-authorization-server/api/delivery-mcp. The root /.well-known/oauth-authorization-server has nothing for this server.

GET /.well-known/oauth-authorization-server/api/delivery-mcp HTTP/1.1
Host: mcp.goautolane.com

{
  "issuer": "https://mcp.goautolane.com/api/delivery-mcp",
  "authorization_endpoint": "https://mcp.goautolane.com/api/delivery-mcp/oauth/authorize",
  "token_endpoint": "https://mcp.goautolane.com/api/delivery-mcp/oauth/token",
  "registration_endpoint": "https://mcp.goautolane.com/api/delivery-mcp/oauth/register",
  "revocation_endpoint": "https://mcp.goautolane.com/api/delivery-mcp/oauth/revoke",
  "response_types_supported": ["code"],
  "grant_types_supported": ["authorization_code", "refresh_token"],
  "code_challenge_methods_supported": ["S256"],
  "token_endpoint_auth_methods_supported": ["none"],
  "revocation_endpoint_auth_methods_supported": ["none"],
  "scopes_supported": ["courier:write"]
}

The response carries Cache-Control: public, max-age=300 and allows any origin.

Step 4: register the client (RFC 7591)

POST /api/delivery-mcp/oauth/register HTTP/1.1
Host: mcp.goautolane.com
Content-Type: application/json
{
  "client_name": "Example Agent",
  "redirect_uris": ["https://agent.example.com/oauth/callback"],
  "token_endpoint_auth_method": "none",
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"]
}

Other fields are ignored. Every redirect URI must be an absolute https URL with no fragment and must match an entry on Autolane’s allowlist exactly, character for character. To add a redirect URI, email support@goautolane.com.

HTTP/1.1 201 Created
Content-Type: application/json
Cache-Control: no-store
{
  "client_id": "mc_k3Jd9sLq2VwX8rT1nB4yZa",
  "client_name": "Example Agent",
  "redirect_uris": ["https://agent.example.com/oauth/callback"],
  "token_endpoint_auth_method": "none",
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "client_id_issued_at": 1791244800
}

Autolane issues no client secret. Errors:

Step 5: send the user to authorize

Open the authorization endpoint in the user’s browser.

https://mcp.goautolane.com/api/delivery-mcp/oauth/authorize
  ?response_type=code
  &client_id=mc_k3Jd9sLq2VwX8rT1nB4yZa
  &redirect_uri=https%3A%2F%2Fagent.example.com%2Foauth%2Fcallback
  &code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM
  &code_challenge_method=S256
  &resource=https%3A%2F%2Fmcp.goautolane.com%2Fapi%2Fdelivery-mcp
  &scope=courier%3Awrite
  &state=af0ifjsldkj

What the user sees.

1. Phone page. Titled “Link your phone”, with the heading “Link your phone to” and the client’s client_name, and the line “Autolane texts a code to the number that will get delivery updates.” The user enters a mobile number and taps Text me a code. Spaces, dots, dashes and parentheses are ignored. A number typed without + is read as follows: 10 digits gain +1 (a US number); any other length gains + and is read as starting with its country code. The result must be in E.164 form (+ and 7 to 15 digits).
2. Code page. Titled “Enter your code”: “We texted a 6-digit code to the number ending” and the last four digits. The user enters the code and taps Link phone.
3. Redirect. Autolane links the number and redirects the browser to your redirect_uri with code and state.

HTTP/1.1 302 Found
Location: https://agent.example.com/oauth/callback?code=SplxlOBeZQQYbYS6WxSbIA&state=af0ifjsldkj
Cache-Control: no-store

The request is good for 10 minutes from the first page load. The authorization code is good for 60 seconds and works once.

Errors shown on the page, never redirected. These come before Autolane trusts the redirect URI (OAuth 2.1 section 4.1.2.1), or after the user has started the phone step.

Errors redirected to the client. Once the client and redirect URI pass, faults go back to redirect_uri with error, error_description and state (when you sent one).

Messages at the phone and code steps. These show on the page, and the user can try again.

Step 6: exchange the code for tokens

The token endpoint takes application/x-www-form-urlencoded only. Send client_id in the body; there is no client secret.

POST /api/delivery-mcp/oauth/token HTTP/1.1
Host: mcp.goautolane.com
Content-Type: application/x-www-form-urlencoded
grant_type=authorization_code
&code=SplxlOBeZQQYbYS6WxSbIA
&redirect_uri=https%3A%2F%2Fagent.example.com%2Foauth%2Fcallback
&code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk
&client_id=mc_k3Jd9sLq2VwX8rT1nB4yZa
&resource=https%3A%2F%2Fmcp.goautolane.com%2Fapi%2Fdelivery-mcp

(Line breaks added for reading; send one line.) code, redirect_uri and code_verifier are required. redirect_uri must equal the one used at authorize. code_verifier is 43 to 128 characters from A-Z a-z 0-9 - . _ ~. resource is optional here; when sent it must equal the resource of the authorization request.

HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: no-store
Pragma: no-cache
{
  "access_token": "example-access-token",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "example-refresh-token",
  "scope": "courier:write"
}

Tokens are opaque strings. Every error has the body {"error": "...", "error_description": "..."}:

Step 7: refresh

POST /api/delivery-mcp/oauth/token HTTP/1.1
Host: mcp.goautolane.com
Content-Type: application/x-www-form-urlencoded
grant_type=refresh_token&refresh_token=example-refresh-token&client_id=mc_k3Jd9sLq2VwX8rT1nB4yZa

The response has the same shape as step 6. Refresh tokens rotate: each refresh revokes the token you sent and returns a new access token and a new refresh token. Store the new refresh token and drop the old one. If a refresh token is used a second time, Autolane revokes every token in its family, and the user must link again.

The refresh also checks that Autolane still enables the user. If not, it answers 400 invalid_grant with This user is not enabled for Autolane Courier, and issues no tokens. Drop the refresh token. A new authorization attempt stops at the phone step.

Step 8: revoke (RFC 7009)

POST /api/delivery-mcp/oauth/revoke HTTP/1.1
Host: mcp.goautolane.com
Content-Type: application/x-www-form-urlencoded
token=example-refresh-token&client_id=mc_k3Jd9sLq2VwX8rT1nB4yZa

Revoking a refresh token revokes its whole family, including live access tokens. Revoking an access token revokes only that token. The answer is 200 with an empty body even when the token is unknown or belongs to another client. token and client_id are required (400 invalid_request, token and client_id are required). The rate limit is the token endpoint’s (429, Too many requests; wait and retry).

Step 9: call the MCP endpoint

Send the access token as a bearer token on every request.

POST /api/delivery-mcp/mcp HTTP/1.1
Host: mcp.goautolane.com
Authorization: Bearer example-access-token
Content-Type: application/json
Accept: application/json, text/event-stream
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_delivery_status","arguments":{"delivery_id":"dlv_4fG7hJ2kL9mN3pQ5rS8tVw"}}}

The endpoint answers 401 with the header and body from step 1 when:

• the request has no Authorization: Bearer header;
• the token is unknown, expired or revoked, is a refresh token, or was issued for another resource;
• Autolane no longer enables the user’s number.

On a 401, refresh once. If the refresh fails with invalid_grant, run authorization again. An access token belongs to one user: every delivery it creates or reads is scoped to that user, and another user’s delivery_id reads as not_found.

Token lifetimes

Call flow

One delivery_id covers a delivery from the first check to the end. Follow this order:

1. Check. Call check_delivery before checkout starts, with the store, the drop-off address, the store’s pickup options, the timing and any store pickup slots. It answers serviceable or a decline, with the price, pickup_windows (best first), the terms, the consent text and quote_expires_at. After a decline, do not place the store order for Autolane delivery.
2. Show. Show the user the price, the terms text and the consent text.
3. Reserve. At checkout, call reserve_delivery with the customer’s name, consent and terms acceptance. Omit contact.phone or send the number the user linked. It holds a vehicle for 15 minutes and returns pickup_profile (what to enter at checkout), pickup_time.select, hold_expires_at and the payment request.
4. Pay. Get the user’s approval for the fee and send the payment credential before you submit the store order. See Payment.
5. Order. Submit the store order in the user’s name, then call confirm_delivery right away with the order number, the items and the confirmation text (and the pickup code when the store shows one). It returns planned_pickup_time, estimated_delivery_window and tracking_url.
6. Track. Poll get_delivery_status and follow next_step. The user can follow the delivery through tracking_url.

Use update_delivery for anything that changes after the reserve. If the user abandons the order or picks another store after a reserve, call cancel_delivery so the vehicle is released.

Clocks

If the hold ran out before you submitted the store order, call reserve_delivery again first. If you submitted the order without a live hold, confirm_delivery takes a new hold itself; when no vehicle is free it declines the delivery with no_capacity instead of booking it.

Tools

The server also offers one resource, courier://description (title “Autolane courier connector”, text/markdown). It holds the connector’s instructions to the agent: the call order, the restricted goods, the payment rules and the check-in rules.

Rules every tool shares

Idempotency. Every tool except get_delivery_status takes an idempotency_key: 8 to 128 characters, with no NUL byte. Keys are scoped to the linked user and kept for 48 hours.

• When you retry a call, send the same key and the same arguments.
• A stored success or decline replays: a retry returns the first answer again (with a fresh tracking_url where one applies).
• The same key with different arguments answers idempotency_conflict.
• A refusal (an envelope with an error) is never stored, so a retry with the same key runs the call again.
• A retry that arrives while the first call is still running waits up to 10 seconds, then answers internal_error with A call with this idempotency_key is still in flight. Retry again with the same key.

Address object (store_address, dropoff_address):

Other shared types:

Result shape. Every call the MCP layer accepts returns a CallToolResult with:

• structuredContent: the response envelope (see Responses);
• content: one text item holding the same envelope as JSON;
• isError: true only when the envelope’s error.code is internal_error.

Other refusals, such as rate_limited, invalid_state or not_found, are ordinary results with an error object in the envelope. Arguments that fail a tool’s input schema (a missing field, a wrong type, a string too long) never reach Autolane’s code: the MCP layer refuses them with its own validation error naming the field, with no envelope, next_step or user_message. Fix the field and retry.

Every envelope has next_step (the exact call to make next) and user_message (one sentence you may show the user). Follow next_step.

check_delivery

Asks whether Autolane can deliver a curbside order from this store to this address. Call it before checkout starts. It creates the delivery and returns its delivery_id.

{
  "retailer_name": "Example Taqueria",
  "store_address": { "street": "123 Example St", "city": "Austin", "state": "TX", "zip": "78701" },
  "dropoff_address": { "street": "456 Sample Ave", "unit": "Apt 2", "city": "Austin", "state": "TX", "zip": "78704" },
  "dropoff_notes": "Blue door at the back",
  "requested_timing": { "type": "asap" },
  "pickup_methods_offered": ["curbside", "counter"],
  "item_count": 3,
  "idempotency_key": "check-7f3a9c21"
}

Response. A serviceable check returns state: "quoted" and these fields:

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "state": "quoted",
  "next_step": "Show the user the price, terms and consent text; at checkout call reserve_delivery with the customer's name, phone, consent and terms acceptance",
  "user_message": "Autolane can deliver this order for $4.95; the vehicle collects it curbside.",
  "retailer_name": "Example Taqueria",
  "store_address": { "street": "123 Example St" },
  "serviceable": true,
  "price": { "amount": "4.95", "currency": "usd" },
  "pickup_windows": [
    { "start": "2026-10-06T23:45:00.000Z", "end": "2026-10-07T00:00:00.000Z" },
    { "start": "2026-10-07T00:00:00.000Z", "end": "2026-10-07T00:15:00.000Z" }
  ],
  "terms": {
    "version": "2026-09-27",
    "text": "Autolane collects your curbside order from the store and delivers it to the address you gave. The delivery fee is charged by Autolane, separately from your order. If the store cannot hand over the order, if it contains items Autolane cannot carry, or if you cancel after the vehicle has collected it, Autolane may still charge the fee. Autolane is not responsible for the contents, quality or availability of your order."
  },
  "consent": {
    "version": "2026-09-27",
    "text": "By providing your phone number you agree that Autolane may send you text messages about this delivery, including a tracking link and arrival updates. Message and data rates may apply. Reply STOP to opt out at any time and HELP for help."
  },
  "quote_expires_at": "2026-10-06T23:55:00.000Z"
}

The check carries no payment_status or fee_cents; those appear after the reserve.

Declines. state: "declined", serviceable: false and a decline_reason: no_curbside, store_not_supported, disqualifying_requirement, out_of_zone, outside_service_hours, no_capacity or timing_not_feasible. next_step is “Tell the user Autolane cannot deliver this order; do not place the retailer order for Autolane delivery”. A decline is stored, so a retry with the same key returns it again.

Errors. rate_limited; idempotency_conflict; internal_error, including Store lookup is unavailable; retry with the same idempotency_key and Address lookup is unavailable; retry with the same idempotency_key.

reserve_delivery

Holds an Autolane vehicle for 15 minutes at checkout. Returns what to enter at checkout and the payment request.

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "customer": { "first_name": "Sam", "last_name": "Rivera" },
  "contact": { "email": "sam@example.com" },
  "contact_consent": { "granted": true, "consent_version": "2026-09-27" },
  "terms_acknowledged": { "accepted": true, "terms_version": "2026-09-27" },
  "pickup_requirements_seen": ["none"],
  "check_in_method": "order_page",
  "idempotency_key": "reserve-7f3a9c21"
}

Response. state: "held" with:

pickup_time depends on the store:

• Stores where the kitchen starts when the vehicle checks in: select is asap, with “Place the order now; the vehicle checks in on arrival and the kitchen starts then”.
• Stores with pickup slots, when a slot fits: select is the slot’s label, id, or start and end, with “Select the retailer pickup slot” and the slot name, then “at checkout”.
• Stores with pickup slots, when none was chosen: select is a time, with “Select the earliest retailer pickup slot at or after” that time.

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "state": "held",
  "next_step": "Get the user's approval for the fee and send the payment credential with update_delivery (update_type payment) before submitting the retailer order; then fill checkout with pickup_profile and pick the slot in pickup_time.select",
  "user_message": "An Autolane vehicle is reserved until 6:45 PM; complete checkout now.",
  "retailer_name": "Example Taqueria",
  "store_address": { "street": "123 Example St" },
  "payment_status": "pending",
  "fee_cents": 495,
  "pickup_profile": {
    "vehicle": { "make": "Tesla", "model": "Model Y", "color": "Grey", "description": "Grey Tesla Model Y" },
    "pickup_phone": "+15125550100",
    "pickup_phone_note": "Voice calls only; this number does not receive texts",
    "order_contact_email": "Use the customer's own email for the order",
    "notes_for_retailer": "Curbside pickup by an Autolane vehicle. The vehicle will check in on arrival. Call the pickup phone with questions."
  },
  "pickup_time": {
    "select": "asap",
    "instruction": "Place the order now; the vehicle checks in on arrival and the kitchen starts then"
  },
  "hold_expires_at": "2026-10-06T23:45:00.000Z",
  "payment": {
    "amount_cents": 495,
    "currency": "usd",
    "seller_profile_id": "profile_example",
    "checkout_url": "https://checkout.stripe.com/c/pay/cs_example",
    "instruction": "send the user to checkout_url; when they finish, call update_delivery (update_type payment, checkout_completed true)"
  },
  "released_delivery_ids": []
}

Keep the order in the user’s own name and use the customer’s own email. Calling reserve_delivery again on the same delivery while the hold is live keeps that hold and its end time; after the hold lapses, it takes a new 15-minute hold. A reserve for a different store releases the user’s earlier hold that has no store order yet; its id appears in released_delivery_ids and user_message adds “An earlier Autolane hold was released.”

Declines. The delivery becomes declined and the hold is released: store_not_supported, disqualifying_requirement, app_only_check_in, customer_unreachable (the number has opted out of texts) or no_capacity. next_step is “Do not submit the retailer order for Autolane delivery; tell the user why”.

Errors.

confirm_delivery

Tells Autolane the store order is placed, and books the delivery. Call it right after you submit the store order.

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "retailer_order_number": "A1042",
  "name_on_order": "Sam Rivera",
  "fulfillment_method": "curbside",
  "items_summary": [
    { "name": "Chicken tacos", "quantity": 2, "modifiers": ["no onions"] },
    { "name": "Horchata", "quantity": 1 }
  ],
  "retailer_confirmation_text": "Thanks, Sam! Order A1042 is in. Check in when you arrive for curbside pickup.",
  "order_subtotal": 18.5,
  "check_in_method": "order_page",
  "pickup_code": { "text": "A1042" },
  "polls_after_turn": true,
  "idempotency_key": "confirm-7f3a9c21"
}

Response. state: "booked" with:

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "state": "booked",
  "next_step": "Poll get_delivery_status; the vehicle collects the order at planned_pickup_time",
  "user_message": "Your Autolane delivery is booked; the vehicle collects the order at 6:45 PM.",
  "retailer_name": "Example Taqueria",
  "store_address": { "street": "123 Example St" },
  "retailer_order_number": "A1042",
  "payment_status": "authorized",
  "fee_cents": 495,
  "sms_reachable": true,
  "planned_pickup_time": "2026-10-06T23:45:00.000Z",
  "estimated_delivery_window": { "start": "2026-10-07T00:00:00.000Z", "end": "2026-10-07T00:15:00.000Z" },
  "tracking_url": "https://autola.ne/t/tok_example"
}

A confirm on a delivery that is already booked returns the booking again.

Declines. The store order already exists, so next_step is “Tell the user the order is ready for regular curbside pickup at the store; Autolane cannot deliver it”. Reasons: customer_unreachable (no reserve ran), store_not_supported, timing_not_feasible, no_capacity and disqualifying_requirement (a restricted item).

Errors.

update_delivery

Reports payment, or a change after the reserve. Send delivery_id, update_type, details and idempotency_key. Autolane checks details against the schema for the type; a mismatch answers invalid_input with details for and the type, then the first problem found.

States in this table are stored states: booked covers what get_delivery_status shows as booked, picked_up, delivered and failed.

The method and check_in_method values are email_link, order_page, call_store, unknown and app_only.

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "update_type": "payment",
  "details": { "checkout_completed": true },
  "idempotency_key": "update-pay-7f3a9c21"
}

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "update_type": "ready_time_change",
  "details": { "new_ready_time": "2026-10-07T00:05:00.000Z" },
  "idempotency_key": "update-ready-7f3a9c21"
}

Response. The common envelope (delivery_id, state, next_step, user_message, retailer_name, store_address, retailer_order_number when known, payment_status, fee_cents) with nothing type-specific. user_message by type:

Declines. Only requirement_found while held declines, with disqualifying_requirement or app_only_check_in.

Errors. invalid_input; not_found; hold_expired (any type but payment, when the hold lapsed and no store order was submitted); invalid_state (including The order is already collected); timing_not_feasible; payment_failed; internal_error (including The payment provider did not answer); idempotency_conflict; rate_limited.

get_delivery_status

Reads the delivery’s state. Send only delivery_id; there is no idempotency key.

{ "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw" }

Response.

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "state": "booked",
  "next_step": "Poll again in 2 minutes",
  "user_message": "An Autolane vehicle is assigned.",
  "retailer_name": "Example Taqueria",
  "store_address": { "street": "123 Example St" },
  "retailer_order_number": "A1042",
  "payment_status": "authorized",
  "fee_cents": 495,
  "sms_reachable": true,
  "status_detail": "vehicle_assigned",
  "stall_id": null,
  "eta_pickup": "2026-10-06T23:45:00.000Z",
  "eta_dropoff": "2026-10-07T00:05:00.000Z",
  "vehicle": { "description": "Grey Tesla Model Y" },
  "fee_charged": false,
  "cached": false,
  "tracking_url": "https://autola.ne/t/tok_example"
}

Errors. not_found, rate_limited, internal_error.

cancel_delivery

Cancels the delivery. Allowed until the vehicle has collected the order. Not needed after update_delivery with order_failed.

{
  "delivery_id": "dlv_4fG7hJ2kL9mN3pQ5rS8tVw",
  "reason": "user_cancelled",
  "reason_text": "The user changed their mind",
  "retailer_order_placed": "false",
  "idempotency_key": "cancel-7f3a9c21"
}

Response. state: "cancelled", payment_status, fee_cents and fee_charged. next_step is “Tell the user the delivery is cancelled”. user_message is “Your Autolane delivery is cancelled and no fee was charged.” (or “Your Autolane delivery is cancelled and the delivery fee was charged.” when fee_charged is true). A cancel before the vehicle collects the order releases the fee authorization.

Errors. not_found; invalid_state (The order is already collected, or Not allowed while and the state on a declined or cancelled delivery); idempotency_conflict; rate_limited; internal_error.

Responses

Envelope

Every accepted call returns this object as structuredContent and as JSON text.

A refusal repeats the delivery’s delivery_id, state, payment_status, retailer_name, store_address, retailer_order_number and fee_cents when the tool had loaded them.

Error codes

Each code has a fixed user_message:

Decline reasons

A decline is not an error. The call succeeds with state: "declined" and a decline_reason, and a retry with the same key returns it again.

When a store order was already submitted, disqualifying_requirement and no_capacity add ” Your order is ready for regular curbside pickup at the store.”

Delivery states

status_detail

When sms_reachable is false, the messages from scheduled through en_route_to_customer add ” Autolane cannot text this phone; share the tracking link.” The arrived_at_customer message does not change and still points to the texted link, which the customer did not get. In that case, do not repeat it: tell the user the vehicle is outside and Autolane’s dispatch will call them to hand over the order. When the customer replies STOP, Autolane alerts dispatch to call them before the vehicle arrives.

When the vehicle reaches the store, do not check in on the store’s order page, email link or confirmation text yourself. Autolane’s supervisor checks the order in with the store by phone. Call update_delivery with checked_in only if the user tells you they already checked the order in themselves.

Polling

next_step on every status read says when to poll again:

Each delivery gets one fresh read every 120 seconds, or every 30 seconds from the time the vehicle leaves for the store until it leaves the store with the order. A read inside that allowance is not refused: it returns the last stored result with cached: true and a fresh tracking_url.

Payment

The fee. Autolane charges a delivery fee, $4.95 today. Every check quotes it (price.amount, in dollars), and every response after the reserve carries it as fee_cents. Autolane charges the fee itself, separately from the store order; the user pays the store for the food as usual.

The payment request. In production, reserve_delivery returns a payment block:

Get the user’s approval for the fee, then pay one of two ways, before you submit the store order:

1. Hosted Checkout. Send the user to checkout_url. When they finish, call update_delivery with update_type: "payment" and details: { "checkout_completed": true }. Autolane checks the session and answers payment_status: "authorized", or payment_failed.
2. Shared payment token. Get a Stripe shared payment token scoped to seller_profile_id and send it with update_delivery (update_type: "payment", details: { "shared_payment_token": "..." }), or on reserve_delivery or confirm_delivery as payment.shared_payment_token.

When a payment is already authorized, the payment block has no checkout_url and instruction says no further payment step is needed.

Authorize, then capture. Autolane authorizes the fee when you send the credential and captures it after the order is delivered. If the delivery ends any other way (cancelled, declined, or not completed), Autolane releases the authorization and charges nothing. The terms let Autolane keep the fee when the store cannot hand over the order, the order holds items Autolane cannot carry, or the user cancels after the vehicle collects it; Autolane does not charge it in those cases today.

Declines. A declined payment answers payment_failed. Get a new credential and send it the same way; each new credential starts a new attempt. Resending the same token returns the same attempt. A token already used on another delivery is refused. If the hold has lapsed, call reserve_delivery again first, then send the credential.

Store order submitted without a payment. Never submit the store order before the fee is authorized. If it happens, Autolane still books the delivery from the recorded order. Status then shows payment_status: "unpaid" (or "failed" after a decline), and next_step asks for a credential. A booked delivery still accepts one, before or after delivery.

Limits

Tool rate limits. A call over a limit answers rate_limited (“Wait and retry”).

OAuth rate limits. Over a limit, the endpoint answers 429 with no Retry-After header.

OAuth body sizes. Form bodies (authorize, token, revoke) up to 16,384 bytes. JSON bodies (register) up to 65,536 bytes.

Main input bounds.

Data and privacy

What Autolane receives. From the agent: the store’s name, address and website; the drop-off address and notes; the requested timing, the store’s pickup options and slots; the customer’s first and last name, the linked mobile number and an optional email; the consent and terms acceptance, with versions and time; pickup requirements and notes; the check-in method, link and instructions; the store order number, name on the order, items (names, quantities, modifiers), subtotal, confirmation text, ready time, store messages and pickup code; and any cancel reason. From sign-in: the mobile number and when it was last verified. Autolane stores authorization codes and tokens only as hashes.

Third parties.

Autolane never receives card numbers. Card details go to Stripe through Checkout or the shared payment token.

Retention. The store’s confirmation text and store messages are deleted 90 days after the delivery closes. Autolane keeps the delivery record, including the consent record, for support, billing and compliance.

Texts the customer receives

Autolane texts the linked mobile number. The links below point to the customer’s own tracking page.

Booking. Sent once, right after the delivery is booked, unless the number has opted out:

Autolane will text you updates about your {store} delivery. Track it here: {tracking link}. Reply HELP for help, STOP to opt out. Msg&data rates may apply.

On the way. Texts when the vehicle sets off for the store, when it leaves the store with the order, and when it is almost at the drop-off.

Arrival. The arrival text carries the link that opens the trunk:

Your {store} delivery is here! Open the trunk from the link below and grab your order: {link}.
The vehicle will wait 5 minutes.

If the vehicle is still waiting near the end of that time, a last-call text follows before it leaves.

Cancelled after booking. When Autolane cannot deliver but the store order stands:

Autolane can't deliver your {store} order #{order number}. Your order is still ready for curbside pickup at the store.
Details: {tracking link}

When the store order did not go through:

Your {store} order didn't go through, so your Autolane delivery is cancelled. You have not been charged.
Details: {tracking link}

A cancel the user asked for sends no text.

STOP, START and HELP.

• Reply STOP to stop the texts. Autolane’s dispatch then calls the customer about any delivery in progress. STOP does not cancel the order. After STOP, sms_reachable reads false; share tracking_url with the user.
• Reply START to resume the texts.
• Reply HELP for help.

The agent’s tracking link. The tracking_url that the tools return is status-only: it shows the delivery’s state, times and vehicle description, with no license plate, no location and no trunk control. It lasts 24 hours, and every status read returns a fresh one. The trunk opens only from the link Autolane texts the customer; for a customer who replied STOP, dispatch calls instead.

Support

Email support@goautolane.com with the delivery_id or the tracking link.