Peckish
This server is an AI ordering agent for DoorDash: it searches restaurants and stores, builds carts, prices real totals, and places orders only after explicit human approval.
Find food and stores — search nearby restaurants by free text, discover non-restaurant stores (grocery, alcohol, convenience, pets, retail), and find specific items inside them.
Inspect menus and items — fetch a store's menu (with filters), full item details including required customization options, and store location metadata.
Manage delivery addresses — list saved addresses and change the account-wide default (with confirmation).
Build and edit carts — check open carts first, add items with nested customizations, show cart contents, remove line items, and delete carts.
Price an order — run an authoritative preview with fee-inclusive totals, tip suggestions, ETAs, credits, PIN requirements, work budgets, and default card; supports priority delivery, scheduling, pickup, and credit opt-out.
Place orders safely — submit only after the preview, tip confirmation, and card are shown and the user approves (hard fail-closed gate); never auto-retried.
Track and review orders — check status (successful/pending/action-required/failed), pull itemized receipts, browse order history, and reorder past orders.
Handle promos — list eligible campaign promos at a store, apply them (campaign or typed codes), and remove them.
Manage payments — list saved cards and identify the default.
Shop groceries — resolve a pantry/ingredient list to real products at a store, including weight-priced items and multi-serving scaling.
Personalize and remember — save/remove durable preferences (dietary rules, allergies, tip habits) and load session context (default address, prefs, local time) at conversation start.
Support group carts — create shareable group carts with per-person spend limits, join as a participant, and add items for account-less guests via name-keyed sub-carts.
Fallback to browser checkout — get a checkout URL for edits the CLI can't make (swap payment, enter promo code, age-restricted orders).
Enables an AI ordering agent for DoorDash, allowing users to search restaurants, browse menus, manage carts, compare fee-included totals, and place orders with explicit user approval.
Peckish 🍜
Feeling peckish? Just ask. An AI ordering agent for DoorDash — it searches,
compares real totals (fees included), builds the cart, and you approve every
order. Built on Claude and DoorDash's official
dd-cli.
One tool layer, three surfaces:
Surface | Start | Best for |
Terminal chat |
| Living in the terminal |
Local web app |
| Consumer-friendly UI: store cards, live quote, Stop button, order modal |
MCP server |
| Claude Desktop / Claude Code users — no API key needed; your Claude subscription powers the model |
Which one is for me?
Comfortable with a terminal? → Terminal chat. Fastest, most informative.
Want something that feels like an app? → Local web app. Cards, live quote, a proper Place-order button.
Already use Claude Desktop or Claude Code? → MCP server. No API key, no separate chat window — Claude itself becomes your ordering agent, and order confirmation appears as a native dialog.
Updates: every release ships with full notes, all artifacts, and a
SHA256SUMS.txt on Releases —
see CHANGELOG.md for the history. Watch the repo (Releases
only) to get notified.
Install in one line — no git clone:
npm install -g peckishPrefer an app? Download the Mac app (.dmg) — guided setup, no terminal at any step. See Mac app below. Everything runs on your own machine either way, because dd-cli holds your DoorDash session there — a Mac (Apple Silicon) or Linux x86_64, including containers and cloud sandboxes: see Linux, containers and headless hosts.
you › Find me a high-protein dinner under $25 that can arrive within 45
minutes. Avoid mushrooms and excessive fees.
⚙ search_restaurants {"query":"grilled chicken bowls","limit":8} ✓ 2.1s
⚙ get_menu {"store_id":"35406455","filter":"chicken"} ✓ 1.8s
⚙ list_carts {"store_id":"35406455"} ✓ 1.2s
⚙ add_items_to_cart {…} ✓ 2.4s
⚙ preview_order {"cart_uuid":"…"} ✓ 3.9s
Best fit: Sharon Korean Kitchen (4.8★, ~24 min) — Grilled Chicken Bulgogi
Bowl, $16.95. No mushrooms listed. Total with fees: $21.40 on your Visa
ending 1234. Suggested Dasher tip is $3.50 — that, another amount, or none?
~$0.04 turn · $0.04 sessionGet started (user guide)
1. Prerequisites
A Mac with Apple Silicon (M1–M4) or Linux x86_64 — the two platforms dd-cli publishes builds for. Peckish is local-first: whichever machine you run it on is the backend on every surface, because that's where dd-cli holds your DoorDash session.
Node.js 20+ —
node --versionto check; install from nodejs.org or brew.DoorDash CLI access (currently waitlist-gated by DoorDash). Peckish requires dd-cli ≥ 0.2.1 — on Linux, ≥ 0.2.2, the first release with Linux builds — and targets ≥ 0.2.6, the current release. Older binaries still order fine; Peckish reads
dd-cli --versionat startup and turns off only what that build can't do (see dd-cli versions). Download the release from doordash-oss/doordash-cli, verify the SHA256 checksum against the published value, then:# macOS (Apple Silicon) tar -xzf dd-cli-v*-darwin-arm64.tar.gz && cd dd-cli-v*-darwin-arm64 # Linux (x86_64) tar -xzf dd-cli-v*-linux-amd64.tar.gz && cd dd-cli-v*-linux-amd64 bash install.sh # both platforms — installs to ~/.local/bin/dd-cli dd-cli login # sign in to DoorDash in your browserNo browser on that machine (container, VM, cloud sandbox)? See Linux, containers and headless hosts.
An Anthropic API key for the terminal/web surfaces (console.anthropic.com) — or skip the key entirely and use the MCP surface with your Claude subscription (step 4).
2. Install Peckish
npm install -g peckishThat's it — you now have three commands: peckish (terminal chat),
peckish-web (web app), and peckish-mcp (MCP server).
git clone https://github.com/CydVilla/peckish.git
cd peckish
npm install
npm test # optional: 25 unit tests, no network needed
npm run dev # terminal chat (or: npm run web / npm run mcp)3. Run it — terminal or web
export ANTHROPIC_API_KEY=sk-ant-… # from console.anthropic.com
peckish # terminal chat
peckish-web # web app → open http://localhost:4747On boot Peckish verifies your DoorDash sign-in, shows your default delivery
address, and flags any open carts you forgot about. If sign-in is missing or
expired, Peckish offers to fix it for you: the terminal asks before launching
dd-cli login (which opens your browser), the web app shows a sign-in card,
and mid-conversation the agent can offer the same assist on any surface — you
approve, sign in in the browser, and it picks up where it left off. On a
machine with no browser, Peckish skips that offer and tells you how to inject
a token instead — see below.
4. Or run it inside Claude — no API key
Claude itself becomes the ordering agent, and your Claude subscription pays for the model. Pick whichever fits your client:
Claude Code — one line:
claude mcp add peckish -- npx -y peckish-mcpClaude Desktop — download peckish-0.2.2.mcpb from
Releases and
double-click it. Claude Desktop installs it like a browser extension: no
terminal, no Node install, no JSON editing.
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"peckish": {
"command": "npx",
"args": ["-y", "peckish-mcp"]
}
}
}If dd-cli isn't at ~/.local/bin/dd-cli, add
"env": { "DD_CLI_PATH": "/your/path/to/dd-cli" } — desktop apps don't
inherit your shell PATH.
Peckish is also listed in the MCP Registry
as io.github.CydVilla/peckish, so clients that browse the registry can find
it directly.
Restart Claude Desktop and ask it to find you dinner. Order confirmation appears as a native dialog; clients that can't render dialogs can browse and build carts but cannot place orders (fail closed).
5. Everyday use
Things to say:
"Find me a high-protein dinner under $25 that can arrive within 45 minutes. Avoid mushrooms and excessive fees."
"Compare the real totals at the top two — fees included."
"Reorder my usual from Sharon Korean."
"What did I spend on delivery last month?"
"Is this place actually good?" (checks web reviews)
"Never mushrooms, ever." → saved permanently; applied automatically next time
"Get me milk, eggs, and a pound of ground beef from Whole Foods."
Placing an order always ends with an explicit confirmation you perform —
typing yes in the terminal, clicking Place order in the web modal, or
approving the dialog in Claude Desktop. Before that, Peckish must show you the
itemized quote, confirm the tip, and name the card being charged. Decline
anything and it backs off.
Controls & housekeeping
Where | What |
Terminal |
|
Web | Stop button cancels a turn · New chat resets · header chip shows session cost · click the address chip to switch your delivery address (editing an address's text happens on doordash.com — Peckish picks it up automatically) |
Both | Preferences live in |
Cost: defaults are tuned for low spend at decent quality — claude-sonnet-5
at medium effort, prompt caching on the system prefix and conversation tail,
and server-side context editing that prunes stale menu payloads in long
sessions. The cost meter shows the approximate spend per turn and per session.
Max quality: DD_AGENT_MODEL=claude-opus-4-8 DD_AGENT_EFFORT=high. (On MCP,
the client chooses and pays for the model.)
Troubleshooting
Symptom | Fix |
| Accept the built-in sign-in assist (it runs |
The same, on a headless Linux box | There's no browser to sign in with: |
Auth errors right after upgrading dd-cli | New CLI versions can need fresh scopes — sign in again (assist, |
|
|
| Install dd-cli (step 1) or set |
| dd-cli ships macOS arm64 and Linux x86_64 only — Intel Macs and Linux arm64 can't run Peckish |
Web app port in use |
|
A turn ran away | Ctrl+C (terminal) / Stop (web) — history rolls back cleanly |
Env vars: DD_AGENT_MODEL (default claude-sonnet-5), DD_AGENT_EFFORT
(low–max, default medium), DD_CLI_PATH, PECKISH_PORT (default 4747),
DD_CLI_ACCESS_TOKEN (read by dd-cli itself — browserless sign-in).
Related MCP server: doordash-mcp
Mac app
A double-clickable app for people who never want to see a terminal:
download Peckish-x.y.z-arm64.dmg from
Releases, drag
Peckish to Applications, and open it.
First launch (Gatekeeper): the app is ad-hoc signed but not notarized (no paid Apple Developer ID), so macOS won't open it on a plain double-click the first time. Right-click the app → "Open" → "Open" (or approve it under System Settings → Privacy & Security). Only needed once.
If macOS instead says "Peckish is damaged and can't be opened", you have a build from before this was fixed, or the download quarantine got confused. Clear it once and it opens normally:
xattr -cr /Applications/Peckish.app
First-run setup happens in the app — three buttons, no terminal:
DoorDash CLI — one-click guided install (downloads the official release, verifies its SHA256 checksum before running anything). If you don't have dd-cli access yet, there's a waitlist link.
Sign in to DoorDash — opens your browser; the app detects when you're done. Your sign-in lives in the macOS keychain.
Anthropic API key — paste it once; it's stored encrypted with Electron
safeStorage(keychain-backed), never in plain text.
Then Open Peckish — same web app, same order-confirmation modal, same safety gates; the app is just a shell that runs the local server for you on a random localhost-only port. Requires Apple Silicon; Node.js is not required (the app bundles its own runtime).
Building it yourself: cd desktop && npm install && npm run dist →
desktop/dist/Peckish-*.dmg.
The .dmg is the one Mac-only surface. The terminal, web and MCP surfaces all
run on Linux too:
Linux, containers and headless hosts
dd-cli v0.2.2 added Linux (amd64) builds, so all three Peckish surfaces run
on Linux x86_64 unchanged — same tools, same order gate, same audit log.
Install dd-cli from the same release page (asset
dd-cli-v<version>-linux-amd64.tar.gz, verify its SHA256, bash install.sh),
then npm install -g peckish. If you put the binary somewhere other than
~/.local/bin/dd-cli, set DD_CLI_PATH — Peckish also checks
/usr/local/bin/dd-cli and your PATH.
With a desktop session (DISPLAY or WAYLAND_DISPLAY set), nothing
changes: dd-cli login opens your browser and the built-in sign-in assist
works exactly as it does on a Mac.
Without one — a container, a VM, a cloud sandbox, SSH with no forwarding —
the browser flow cannot complete, so Peckish stops offering it (no spawned
login that hangs forever, no "run dd-cli login" advice that can't work) and
points at the token path instead:
# 1. on a machine that HAS a browser (dd-cli ≥ 0.2.2)
dd-cli export-token
# 2. in the environment that runs Peckish
export DD_CLI_ACCESS_TOKEN='<the token>'
peckish # or peckish-web / peckish-mcpdd-cli picks the token up from the environment Peckish passes down, so every surface authenticates without a keychain or a browser.
That token is live access to your DoorDash account — it can place real orders. Treat it like a password: keep it in your runtime's secret store, not in an image layer, a
docker run -ein your shell history, or a committed.env. Mint a fresh one withdd-cli export-tokenwhen it expires.The order gate does not change. Placing an order still needs your explicit approval on the surface you're using (typed
yes, the web modal, or the MCP dialog) — headless means no browser, not unattended ordering.peckish-webin a container binds127.0.0.1inside the container by design, so a published port (-p 4747:4747) can't reach it. Run the container with--network host(Linux), or use the terminal or MCP surface, which need no port at all.Not supported: Linux arm64 and Intel Macs — dd-cli publishes no build for either, and Peckish says so explicitly instead of failing obscurely.
What it does
Search → menus → cart → preview → confirm → submit, with the real fee/ETA quote (
order preview) driving every recommendation.Comparison shopping: builds carts at up to 3 finalists, compares true totals + fee share + ETA, recommends one, deletes the losers.
Fee tactics: promo scanning with consent, pickup-vs-delivery comparison, DoorDash credits surfaced, DashPass status shown.
Memory: dietary rules and habits persist across sessions and surfaces.
History: "my usual" from order frequency, honest spend breakdowns from receipts, reorders with silent-drop detection.
Web reviews via Claude's server-side web search (never used for prices — dd-cli is the only source of truth for ordering data).
Group carts (new in 0.4.0): "start a group order for the team, $25 each" — creates a shareable cart link, optional per-person spend limit, host reviews and submits when everyone's in.
Guest sub-carts (new): order for people who have no DoorDash account at all — "add a veggie burrito for Luke Wulf" puts their items in their own sub-cart of your group cart. They never sign in, never install anything. Name them the same way each time and their items stay together; ask "who's ordered?" to see who is tracked. The per-guest credential DoorDash issues is held by Peckish and never shown to you or the model — see Guest sub-carts.
Express delivery (new): asks for Priority when you want it fastest — offered per-cart, priced into the quote before you approve.
Credits control (new): DoorDash credits apply by default; say "don't use my credits" to opt out for an order.
Enterprise chains (new): Domino's, Sweetgreen, Dave's Hot Chicken and other big chains are now orderable (dd-cli ≥ 0.2.1).
Search filters (new): "somewhere cheap that can be here in 30 minutes" narrows server-side — DashPass-only, price tier, max ETA, search radius — instead of pulling 30 results and sifting.
Promo-aware menus (new): menus and item details carry the store's live promotions and which items qualify, priced against the delivery address, so a deal gets offered while you're still choosing rather than at checkout.
Pickup at a glance (new): search results say per store whether pickup is available now, schedulable, or opens later — useful when the fees annoy you.
Schedule ahead (new): a store that's closed now is offered as "opens at 6, I can schedule it" instead of being dropped from the results.
Weight-priced items (new): deli, butcher and produce items take a decimal quantity in their own unit, and Peckish tells you the total is an estimate because the charge follows the actual weight.
Address lookup (new): deliver somewhere that isn't saved yet — Peckish resolves the address, has you pick the exact match, and asks before saving it (it becomes your account default).
Live order tracking (new): "where's my food?" answers from the full lifecycle — placement, progress, current ETA, late trend, cancellation reason — not just "did it go through".
Work benefits (company budgets + expense codes), scheduled delivery, pickup, groceries/retail/pets/alcohol, group order history.
Guest sub-carts
A DoorDash group cart holds items for two kinds of people, and they work differently:
Participants have their own DoorDash account. They open the group cart link and add their own items under their own identity. Peckish joins one on your behalf with the link itself.
Guests have no account and never touch DoorDash. The host's account adds on their behalf, into a sub-cart tagged with their name. This is what makes "just tell me what everyone wants" work for a team where only one person has the CLI.
DoorDash issues a per-guest token on that guest's first add. It is a bearer
credential for their sub-cart, it is returned exactly once — cart show never
echoes it and there is no endpoint to fetch it again — and dd-cli's own
guidance is to keep it server-side and out of logs.
So Peckish keeps it. Tokens are stored in ~/.peckish/guests.json (mode
0600) keyed by cart and guest name, stripped out of every tool result before
the model sees one, and therefore never written to the session audit log, which
records a preview of every result. The model works purely in names: it says
"Luke Wulf" and Peckish supplies the right credential. There is no way for the
assistant to read, request or repeat a token, which is the point.
Two consequences worth knowing:
Spelling matters. "Luke Wulf" and "Luke Wolf" are two guests with two sub-carts. Peckish ignores case and extra spaces, nothing more.
The file matters. Delete it mid-cart and the affected guests' continuity is gone — the only recovery is starting them again under the same name, which forks their line items. Peckish drops a cart's guests once its order is submitted or the cart is deleted, and prunes anything older than 30 days.
dd-cli versions
dd-cli is a separate binary on its own release cadence, and every release since
0.2.2 has added flags. Peckish probes dd-cli --version once per process and
degrades instead of breaking:
dd-cli | What it unlocks in Peckish |
≥ 0.2.1 | Baseline: |
≥ 0.2.2 | Linux builds, |
≥ 0.2.3 |
|
≥ 0.2.4 | Promotions on menus and item details, searching from a saved |
≥ 0.2.5 | Search filters, per-store pickup availability, schedule-ahead windows, weight-priced items |
≥ 0.2.6 | Paying on a chosen card, DoubleDash, cross-retailer price comparison, Meal Manager calendars, saving an address without making it default |
Two scripts keep this honest:
node scripts/verify-dd-cli.mjs # what YOUR dd-cli actually accepts
node scripts/check-dd-cli-release.mjs # is a newer dd-cli out?verify-dd-cli.mjs runs the commands Peckish runs against your real,
signed-in binary and reports which flags it accepts and what field names the
responses carry. It is read-only — no carts, no saved addresses, no orders.
Run it after a dd-cli upgrade, or when something Peckish sends comes back
rejected — docs/dd-cli-verification.md is the
checklist for acting on what it reports. check-dd-cli-release.mjs runs weekly in CI and files an issue when
dd-cli publishes a release newer than the one Peckish targets.
Behaviour Peckish applies on its own — like pricing menus against your saved address so promo eligibility is right — stays off until the version check confirms the binary supports it. A flag the model asked for explicitly is always passed through, so an old binary answers with its own error naming the flag rather than Peckish silently ignoring the request. The detected version goes into the session context, so the assistant knows what it can offer and suggests an upgrade only when you ask for something the binary can't do.
Architecture
terminal REPL local web app MCP client (Claude Desktop…)
src/index.ts src/web.ts + public/ src/mcp.ts
└────────────┬─────────┘ │ (client's model reasons;
↓ │ server instructions guide it)
Claude agent loop, streaming │
src/agent.ts · claude-sonnet-5 · strict tools │
· adaptive thinking · context editing │
· prompt caching · web_search · cost meter │
└───────────────┬─────────────────┘
↓
38 typed tools — src/tools.ts (strict: true)
↓
sanitizing wrapper — src/ddcli.ts
↓
dd-cli --json-output → DoorDashSafety model
Placing an order always requires an explicit human approval rendered by the surface, not by the model:
Surface | The gate |
Terminal | Type |
Web | "Place order" modal (declines automatically after 5 min) |
MCP | Client elicitation dialog; clients without elicitation cannot place orders (fail closed) |
Also on every surface:
Strict tool schemas — the API guarantees tool arguments validate before any handler runs (no malformed-argument class).
Abortable turns — Ctrl+C / Stop rolls history back to the turn start.
Audit log — every tool call, argument set, duration, confirmation outcome, and submit result in
~/.peckish/logs/*.jsonl.Tip confirmed + card named before any submit ask; submit never auto-retries (not idempotent); success reported only after
order statusconfirms.Merchant text treated as data (widget/assistant-instruction fields stripped); read-only CLI calls retry once on transient errors, mutations never do.
Web server is localhost-only (Host + Origin checks).
What Peckish shares with DoorDash
dd-cli ≥ 0.2.1 requires an --intent note on every command, which DoorDash
says it may review for research and product improvement. DoorDash's documented
format asks for your verbatim prompt — but food prompts routinely contain
dietary, health, and religious signals, which DoorDash's own guidance says to
avoid. So Peckish defaults to privacy:
What is sent: a one-line goal summary authored by the model at generic altitude (e.g.
Summary: Help the user order dinner), plus an explicituser prompt/purpose: "(not shared — Peckish privacy default)"marker.What is never sent by default: your verbatim words, dietary rules, budgets, names, saved preferences, or conversation content.
Opt in to the full format: set
PECKISH_INTENT_VERBATIM=1and the intent will include your opening request verbatim, as DoorDash's docs ask.
Independent of intent, DoorDash necessarily sees the API traffic itself (searches, carts, orders) — that's inherent to ordering.
Repo map
File | What it is |
| Terminal REPL surface (abort, cost lines, /cost) |
| Web surface: SSE streaming, cards, Stop, confirm modal, Origin guard |
| MCP stdio server: 38 tools + session context, instructions, elicitation gates |
| System prompt + streaming tool loop (beta: context editing; web_search; usage) |
| Tool schemas (strictified) + handlers; menu trimming/filtering |
|
|
| Supported dd-cli targets + whether sign-in can use a browser here or needs an injected token |
| Pluggable confirmation gates (fail closed) |
| Cost accounting · JSONL audit log |
| Preference persistence ( |
| 108 unit tests ( |
| Electron shell for the Mac app (.dmg): onboarding + server launcher, no agent logic |
| The |
| Claude Desktop extension ( |
| MCP Registry metadata ( |
Releasing
Everything ships from one tag. .github/workflows/release.yml publishes both
npm packages, registers the MCP Registry entry, builds the .mcpb and the
.dmg, and attaches both to the GitHub release:
npm version patch # or edit the versions by hand
git push && git push --tagsEvery publish step is skip-if-already-published, so re-running a tag after a
failure is safe. .github/workflows/ci.yml runs typecheck, tests, a metadata
consistency check, and a real MCP handshake on every push.
scripts/check-consistency.mjs guards the metadata that spans files and drifts
silently — the registry namespace casing, matching server.json name and
mcpName, the 100-character registry description cap, and the extension's
advertised tool list. Run it locally before tagging.
npm — either configure
trusted publishing on npmjs.com for
both peckish and peckish-mcp (provider: GitHub Actions, repo
CydVilla/peckish, workflow release.yml) so no secret is needed, or add an
NPM_TOKEN repository secret using a granular access token with "bypass 2FA"
enabled.
MCP Registry — nothing to configure. The workflow authenticates with
mcp-publisher login github-oidc, and GitHub's OIDC token proves the repo owner
is CydVilla, which grants the io.github.CydVilla/* namespace.
Mac app signing — the .dmg is built unsigned. Notarized builds would need
an Apple Developer ID plus CSC_LINK/CSC_KEY_PASSWORD and notarization
secrets.
Notes & limitations
Local-first by design: hosted delivery (SMS bots, voice) would require DoorDash's partner API — your own machine is the backend here.
One open cart per store (DoorDash rule) — Peckish collision-checks and asks.
payment-method listsees cards only; wallet defaults (Apple Pay etc.) are confirmed generically or via the browser checkout URL.Age-restricted items can't be submitted by an agent — checkout URL fallback.
Popularity data is deliberately unused (per dd-cli guidance); web reviews fill that gap with attribution.
Cost figures are close estimates from token usage at list prices.
Available Tools
39 toolsadd_addressADestructive
Save a candidate from find_address to the user's DoorDash account. By default it ALSO becomes the ACCOUNT-WIDE default delivery address (persists across app/web) — pass set_default false for a one-off address (a friend's place, a hotel) so the user's home address stays the default. Prompts the user for approval first. Confirm the exact address with the user — including apartment/suite accuracy — before calling; a wrong address means a lost order.
Inputs: intent (required), place_id (required), printable_address (required), set_default.
add_doubledash_itemA
Add ONE item from an offered store to an existing delivery. Returns a cart_id — then preview_order it as cart_uuid, show the user the summary, and submit only on their go-ahead. If the response has link_confirmed false the item did NOT attach: do not preview, do not submit, and do not add it again — tell the user. Needs dd-cli >= 0.2.6.
Inputs: intent (required), item_id (required), store_id (required), query, +5 more.
add_items_to_cartA
Add items to a cart (creates one if no cart_uuid passed and none open at the store). Also the only way to add for a GUEST — see guest_first_name. APPEND semantics: re-adding an item_id SUMS quantities. Items need item_id + item_name + quantity; customizations go in nested_options[] (entries: id, name, quantity, optional recursive options[]). Weight-priced items (deli, butcher, produce) take a decimal quantity in their own unit — the final charge is by actual weight, so tell the user the price is an estimate. Items the merchant ships with default modifications keep them unless you pass default_handling 'exact'. On required-options failure the response lists required_options[] — ask the user to choose, then retry. Check list_carts first.
Inputs: items (required), intent (required), menu_id (required), store_id (required), +7 more.
apply_promoA
Apply a promo to a cart. Campaign promos from list_promos need promo_code + campaign_id + ad_group_id + ad_id; user-typed codes need only promo_code. On failure: check subtotal vs the promo's stated minimum. Re-preview after.
Inputs: intent (required), cart_uuid (required), promo_code (required), ad_id, +2 more.
build_grocery_listA
Resolve a grocery/pantry list to real products at one store (raw ingredients only — NOT restaurant food). STATELESS: every call REPLACES the list, so always send the complete list. Weight items take decimal quantity (0.5 = half lb) only when purchase_type is MEASUREMENT; eggs are per dozen. Verify resolved items[].name with the user before carting. Vague asks: cap at 20 items and show your picks.
Inputs: items (required), intent (required), servings, store_id, +1 more.
delete_cartADestructive
Empty a cart and abandon it (cart_uuid becomes invalid). Only on user request/consent — e.g. replacing a stale cart at the same store.
Inputs: intent (required), cart_uuid (required).
find_addressARead-only
Look up a street address the user typed and get back candidate addresses with place_ids. Use ONLY when the user wants to deliver somewhere not already in list_addresses — check that first. Nothing is saved: pass the chosen candidate's place_id to add_address.
Inputs: query (required), intent (required).
find_item_across_retailersARead-only
Compare ONE grocery/retail item's price across nearby stores — use when the user asks who has something cheapest. Retail and grocery only, never restaurants. To search inside one store already chosen, use find_items instead. Only compare prices across rows with the same purchase_type AND measurement_unit; rows with unavailable_reason have no confirmed price. Empty results means no nearby store carries it — widen radius before saying it doesn't exist. Needs dd-cli >= 0.2.6.
Inputs: query (required), intent (required), lat, lng, +2 more.
find_itemsARead-only
Search items inside ONE retail/grocery store by name — returns item_ids for cart adds, keyed per query. Empty for restaurants (use get_menu there).
Inputs: intent (required), queries (required), store_id (required).
find_storesARead-only
Discover NON-restaurant stores near the default address (16-mile radius): grocery (default), alcohol, convenience, pets, retail, or nv (all non-restaurant). distance_meters is meters — divide by 1609 for miles. Restaurant queries belong in search_restaurants.
Inputs: intent (required), lat, lng, max, +2 more.
get_checkout_urlA
Browser checkout URL for a cart — FALLBACK ONLY, for edits the CLI can't make: swap payment method, opt out of credits, change address mid-checkout, enter a promo code, or finish an age-restricted order. Do not offer by default after previews.
Inputs: intent (required), cart_uuid (required).
get_grocery_item_detailsARead-only
Details for a retail/grocery item (pricing, options) + menu_id fallback source for grocery cart adds. Restaurants: use get_restaurant_item_details.
Inputs: intent (required), item_id (required), store_id (required).
get_meal_manager_calendarsARead-only
Corporate Meal Manager (DoorDash for Work) calendars and their dated group carts. An EMPTY calendars list is the normal result for anyone not on a Meal Manager team — report that plainly, never as an error. Join a listed cart via add_items_to_cart with its cart_id as cart_uuid plus group_cart. Needs dd-cli >= 0.2.6.
Inputs: intent (required), date.
get_order_historyARead-only
Past orders (default 50 orders / 90 days, max 100 / 365): store, items (item_id, name, quantity), order_date, order_fulfilled_at, order_uuid, is_reorderable, fulfillment_type, is_group_order. Rows carry no total and no per-item price — use get_receipt for money. Use to analyze habits ('my usual'), find reorder targets, or locate a specific past order (scan all results; if page_full, re-query higher/wider).
Inputs: intent (required), max, days, include_group_order.
get_order_statusARead-only
Track a submitted order. The order is under result (result.status, plus quoted/actual_delivery_time, actual_pickup_time, eta_trend, late_reason, cancellation_reason, merchant_name, is_pickup) — read the derived lifecycle block rather than matching status text: order_created, is_terminal, keep_polling, not_found. Statuses: pending (check again) | placed (created successfully) | scheduled/store_confirmed/ready_for_pickup/dasher_assigned/dasher_at_store/picked_up/dasher_nearby (delivery or pickup underway) | completed | cancelled | action_required (user must verify in app) | order_declined. Answer 'where is my order?' from this rather than guessing from the submit response.
Inputs: intent (required), order_uuid (required).
get_receiptARead-only
Itemized receipt for one past order (subtotal, fees, tax, tip, total, card last4). Sensitive — show only to the user.
Inputs: intent (required), order_uuid (required).
get_restaurant_item_detailsARead-only
Full details for one restaurant menu item: price, description, any promotion it qualifies for, and extras[] customization groups (each with options[] holding option_id choices, min/max selections). REQUIRED before adding any item with has_required_modifiers. Pass selected options[].option_id values as nested_options when adding to cart (never extra_id).
Inputs: intent (required), item_id (required), menu_id (required), store_id (required), +1 more.
get_session_contextARead-only
Load the user's ordering context: default delivery address, saved dietary/budget preferences, and current local time. Call once at the start of an ordering conversation.
Inputs: intent (required).
get_store_detailsARead-only
Store business metadata incl. printable_address — use when the user needs to know WHICH physical location a store is ('which Starbucks?').
Inputs: intent (required), store_id (required).
list_addressesARead-only
List the user's saved DoorDash delivery addresses (label, printable address, default flag). Use to resolve 'home'/'work' references. Delivery always uses the account default address.
Inputs: intent (required).
list_cart_guestsARead-only
Names of the guests Peckish is tracking on a group cart — people with no DoorDash account whose items the host added for them. Use to answer 'who has ordered?' and to check a name before adding again (same name = same sub-cart). Real participants who joined with their own login are not listed; their items show in show_cart.
Inputs: intent (required), cart_uuid (required).
list_cartsARead-only
List the user's open (unsubmitted) carts: cart_uuid, store, items, timestamps (epoch ms). ALWAYS check this before creating a cart at a store — only one open cart per store is allowed; if one exists, ask the user whether to extend or replace it.
Inputs: intent (required), store_id.
list_doubledash_optionsARead-only
Stores whose items can join an EXISTING delivery with no extra delivery fee. Offer this after an order is placed — get_order_status carries a doubledash offer with an expires_at; only offer while that deadline is still in the future, and tell the user the deadline. Say nothing about DoubleDash when there is no offer, it has expired, or stores is empty. Pass order_uuid for a placed order or cart_uuid for an unsubmitted delivery cart. Needs dd-cli >= 0.2.6.
Inputs: intent (required), cart_uuid, max_stores, order_uuid.
list_payment_methodsARead-only
Saved cards + which is default. Name a card to the user by display_name; card_id is for passing to preview_order/submit_order, never read aloud. Cards ONLY — wallets/gift cards are invisible here; never conclude 'no payment method' from an empty list (offer checkout-url instead). Skip any card with is_expired true.
Inputs: intent (required).
list_promosARead-only
Campaign promos eligible at a store for this user (may be empty — that's normal). To apply one to a cart use apply_promo with all four ids; preview_order shows what's actually discounting a cart.
Inputs: intent (required), store_id (required).
preview_orderA
Authoritative pricing + logistics for a cart (read-only, no charge): display_summary (show VERBATIM to the user), quote {net_total_before_tip = the real total, line_items fee breakdown, tips_suggestion (cents), delivery_availability ETAs, credits, PIN requirement, work budgets}, and default_card (name it by display_name). Re-run after ANY cart change. Pass include_work_benefits when the user mentions work/office/company/team/expense or delivers to a Work address. Budget checks: compare the user's cap against net_total_before_tip (tip adds on top).
Inputs: intent (required), cart_uuid (required), card_id, priority, +5 more.
remove_cart_itemA
Remove one line item from a cart. cart_item_id = items[].id from show_cart (NOT the menu item_id).
Inputs: intent (required), cart_uuid (required), cart_item_id (required).
remove_preferenceA
Delete one saved user preference when the user retracts or reverses it ('actually, mushrooms are fine now', 'stop defaulting to pickup'). Pass the note's exact stored text — as listed in the session context or returned by save_preference — since matching is by exact text (case-insensitive). Returns the remaining preferences so you can confirm what's still active.
Inputs: note (required), intent (required).
remove_promoA
Remove an applied promo (pass the same ids used at apply). Re-preview after.
Inputs: intent (required), cart_uuid (required), promo_code (required), ad_id, +2 more.
reorderA
Create a NEW cart from a past order. Check list_carts for the store first (one open cart per store). Afterwards ALWAYS preview_order and diff items vs the original — out-of-stock items drop silently; call out any drops before asking about submitting.
Inputs: intent (required), order_uuid (required).
save_preferenceA
Persist a durable user preference across sessions (dietary rule, allergy, budget habit, tip default). Save when the user states one ('no mushrooms ever', 'I usually tip 20%'). Keep each note short and self-contained.
Inputs: note (required), intent (required).
search_doubledashARead-only
Search for a specific item across the stores that can join a placed order's delivery, when the suggested items in list_doubledash_options don't cover what the user wants. Placed orders only. Pass the SAME query to add_doubledash_item. Needs dd-cli >= 0.2.6.
Inputs: query (required), intent (required), order_uuid (required), max_stores.
search_restaurantsARead-only
Search nearby restaurants by free-text query. Searches from the user's default saved address unless address_id or lat/lng is given. Returns store_id, name, distance, delivery_time estimate, rating, and pickup availability (offers_pickup, asap/scheduled_pickup_availability, next_open_time_asap_pickup_ms — use these before promising pickup). Stores with is_link_out=true cannot be ordered through this agent. Restaurant-focused — use find_stores for grocery/retail/pharmacy/pets/alcohol. Filters (dashpass_only, price_tier, distance_preference, max_eta_minutes) narrow server-side — prefer them over asking for 30 results and filtering by hand.
Inputs: query (required), intent (required), lat, lng, +6 more.
set_default_addressADestructive
Change the ACCOUNT-WIDE default delivery address (persists across app/web). Prompts the user y/N in the terminal before applying. Only call when the user asked to deliver somewhere else.
Inputs: intent (required), address_id (required), printable_address (required).
set_default_payment_methodADestructive
Change the ACCOUNT-WIDE default card — persists across the DoorDash app/web and every future order. Use ONLY when the user asks to change their default. To pay for ONE order on another card, pass card_id to preview_order and submit_order instead. Prompts the user at the terminal. Re-preview any existing cart afterwards. Needs dd-cli >= 0.2.6.
Inputs: intent (required), card_id (required), display_name.
show_cartARead-only
Show cart contents (no pricing — use preview_order for that). items[].id is the cart-LINE id used by remove_cart_item; items[].item_id is the menu item id. Don't swap them.
Inputs: intent (required), cart_uuid (required).
start_signinA
Fix a broken DoorDash sign-in WITHOUT sending the user to a terminal. Call when a tool fails with 'sign-in is missing or expired' AND the user wants to continue: after they approve a confirmation prompt, this launches dd-cli login (opens their browser) and polls until the sign-in works, up to ~45s per call. If it returns login_in_progress, call it again to keep waiting — repeat calls never open a second window. On signed_in, retry the request that originally failed. On browser_signin_unavailable (headless Linux container/VM: no browser to sign in with) do NOT call it again — relay its note, which tells the user how to inject a DD_CLI_ACCESS_TOKEN instead.
Inputs: intent (required).
submit_orderADestructive
Place the order — charges the user's real payment method. HARD GATE: the terminal asks the user to type 'yes'; a decline returns declined_by_user. Call ONLY after: (1) preview shown, (2) tip explicitly confirmed (delivery; pickup = 0 without asking), (3) payment method named to the user, (4) the user clearly said to place it. NOT idempotent — never retry without checking get_order_status first. Report success only when the response's lifecycle.order_created is true.
Inputs: intent (required), cart_uuid (required), tip_cents (required), confirmation_summary (required), +10 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
The tools are mostly clearly separated by resource and action, and descriptions explicitly route restaurant vs. retail, one-store vs. cross-store, and cart preview vs. cart contents. A few adjacent pairs remain potentially confusable, such as preview_order vs. show_cart vs. get_checkout_url and add_items_to_cart vs. add_doubledash_item, but the descriptions usually resolve them.
Almost all names use consistent snake_case with a verb_noun pattern, such as list_carts, remove_cart_item, get_order_status, and save_preference. Minor deviations like reorder and a few less explicitly noun-shaped names keep it from perfect consistency.
The domain is broad, but 39 tools is well above a well-scoped surface and crosses into a heavy, fragmented toolset. Many niche variants for retail, DoubleDash, promotions, addresses, and carts multiply the surface area even though each has a stated purpose.
Core ordering lifecycle coverage is strong: search, menus, item details, carts, promos, addresses, payment, submit, status, receipt, history, reorder, and preferences are all present. There are still gaps such as no explicit order-cancellation tool, no address deletion/editing beyond add/default, and no dedicated tip-setting or scheduling operation.
Maintenance
Related MCP Connectors
DoorDash MCP server for ChatGPT, Claude and any AI agent: search stores, read store menu, add item to cart, preview order total with fees, submit order, list past orders, get order status and reorder a past order in your own DoorDash account. Cotlet works in the account through your Cloud Browser, a real Chrome where you sign in to DoorDash yourself; Cotlet does not store your password and you need no DoorDash API key. About the official DoorDash API: DoorDash has no public API for ordering as a consumer (checked 27 Oct 2026). Its public APIs, Drive and Marketplace, are for merchants and delivery partners. Setup and FAQ: https://cotlet.dev/integrations/doordash-api-mcp-server
Order food from Cordering white-label restaurants: browse menus, confirm, then place an order.
AI food ordering across Canada — 17,000+ restaurants, 89 cities, real UberEats + DoorDash.
Pickup orders at Japanese restaurants for AI agents: find stores, read menus, place orders. No auth.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI agents to search restaurants, browse menus, and manage DoorDash carts through structured JSON data. It leverages a background browser to handle authentication and direct GraphQL API calls for efficient interaction.718 npm2MIT
- AlicenseBqualityDmaintenanceEnables AI agents to search restaurants, browse menus, manage carts, and place orders on DoorDash programmatically. It utilizes a headless browser to interact with DoorDash's GraphQL API and bypass anti-bot protections for the full delivery lifecycle.2218 npm4MIT
- AlicenseNot gradedqualityDmaintenanceEnables ordering DoorDash via Poke over text, with tools for restaurant discovery, cart management, promo application, and order submission requiring explicit user confirmation.MIT
- FlicenseNot gradedqualityCmaintenanceLocal MCP wrapper for DoorDash CLI on macOS, exposing DoorDash services like restaurant search, menus, carts, ordering, and payments as MCP tools with secure token-based access.-