MCP App Store
by KeenEthics
Drivethrough icon

Drivethrough MCP Server for ChatGPT

By Made by Tim LLC

Overview

Describe the website you want, and it's live in seconds. No code, no settings, no website builder to learn - you say what you want, ChatGPT builds it, and Drivethrough puts it online. Every site starts private, visible only to you. Share it like a doc link - send it to exactly the people you choose, no accounts needed - or make it public for the world when you're ready. That makes Drivethrough good for two kinds of sites: the little ones that were never for the whole internet (trip plans, the family recipe book, a tool that splits the bills), and the public ones you've been meaning to make (the plumbing business, the band, the bake sale). Changing a site is just asking again. Every change is saved, so you can roll back to any earlier version instantly. Forms and RSVPs land in your email. Public sites can use your own web address, and it's free to start.

How to connect

  1. ChatGPT: Open the Drivethrough listing in the ChatGPT app directory and choose Connect. ChatGPT listing Drivethrough exposes 21 tools here.

Tools

check_domain

ChatGPT
Check a site's custom domain, read-only. "status": live verification progress — pending_dns (waiting on DNS records) → pending_ssl (certificate issuing) → active (serving with TLS); poll after setup and tell the user when it's live. "connect": look up one-click setup at the user's registrar (GoDaddy, Cloudflare, IONOS, Squarespace, …) — when a URL comes back, relay it and their registrar creates the records in one click; otherwise relay the copy-paste records manage_domain attach returned.

create_db

ChatGPT
Provision the per-site database. Idempotent. Deploying a drivethrough.json that declares types does this automatically. Site pages read and write rows via the same-origin Data API: GET /api/data?type=X lists, POST /api/data with {type, json} inserts. Anonymous writes (write: "public", or "viewers" on a public site) additionally require Cloudflare Turnstile in that POST: GET /api/config for the turnstile_site_key, load https://challenges.cloudflare.com/turnstile/v0/api.js, render <div class="cf-turnstile" data-sitekey="…"></div> inside the form, and send the widget's "cf-turnstile-response" input value as "turnstile_token" in the body. The widget is usually invisible; owner and invited-viewer writes on private sites skip it entirely.

create_upload

ChatGPT
Mint a short-lived upload link the USER opens in their browser to add local files (photos, PDFs, audio, video) — the route for binary assets when you cannot reach the bytes and they aren't hosted anywhere. Two-step: (1) relay the returned upload_url as a clickable link — it opens a drag-and-drop page (no sign-in needed) that takes up to 20 files, 25 MB each, and expires in 30 minutes. (2) When the user says they're done, call this tool again with the SAME site plus the returned session — it lists what they uploaded ({upload_id, filename, size_bytes}); ship each with deploy_site files: [{path, upload_id}] (mode "patch" adds them to a live site). Never base64-encode a file instead — but if the bytes are already in YOUR runtime (e.g. a chat attachment mounted in your sandbox) AND you can make HTTP requests, you may PUT them straight to the returned put_url (one file per request, its filename as the last path segment) without involving the user. Choosing a route for a binary asset: already on the public web → deploy_site {path, source_url}; this server runs on the user's machine → deploy the directory; file only in the chat or on the user's machine → this tool. Tiny pasted assets (≤1 MB, e.g. a favicon) may still go inline as base64 content. Upload ids are single-use: the deploy that references one consumes it (the bundle keeps the bytes; the staged copy is removed and its quota refunded) — to rename or duplicate the file later, use deploy_site {path, from_path}. An upload no deploy references within 24 hours is deleted, so deploy soon after the user confirms. Pass size_bytes when the user told you a file's size — quota errors then surface here instead of failing their upload.

delete_site

ChatGPT
Delete a site. Two-phase and safe: the site leaves the driveway immediately (guests lose access, share links are revoked, the name frees up) but stays recoverable for 30 days via restore_site. Only after 30 days is it destroyed for good.

deploy_site

ChatGPT
Deploy a site to Drivethrough. Idempotent: creates the site if needed, else ships a new version. Sites are private by default. Pass files with generated content — the platform assembles the bundle server-side, so no local filesystem or build toolchain is needed. Content you generated counts even once it is sitting in a file: if you wrote the page to your own sandbox, read that text back and send it as files[].content. Images and other binary assets — pick the route by where the bytes live: already at a public URL → {path, source_url} (fetched server-side); a local file — the user's, or an attachment already in your runtime — → create_upload first, then {path, upload_id}; already deployed on this site → {path, from_path} copies it server-side (with delete_paths, a move). Never base64-encode a file, by hand or in code — inline base64 is capped at 1 MB and is only for tiny pasted assets; a file shipped via upload_id is referenced, never additionally inlined. To rework an already-deployed site, read it back with get_site first, then deploy with mode "patch" — only the files that change. For small text changes to existing files, use edit_site instead: it sends find/replace pairs, never whole files. Every deploy's version number is a restore point: prior versions stay listed (get_site history), diffable, viewable (preview_site), and returnable (revert_site). A successful deploy may still return warnings — things that will bite at runtime but only for visitors, never for you: a form type anonymous visitors can write with no page loading the Turnstile widget, or a page that fetches a data type its visitors have no permission to read. Resolve them before telling the user it works.

edit_site

ChatGPT
Edit a deployed site's text files in place — the efficient way to make small changes (wording, values, a link, a style tweak) to a live site. Send only find/replace pairs, never whole file contents: the platform reads the current version, applies the edits, and ships a new version with everything else carried forward. Prefer this over get_site + deploy_site whenever the change is small relative to the file. Each find must match the deployed text exactly (whitespace included) and exactly once — add surrounding context to pin down one occurrence, or set replace_all. All-or-nothing: if any edit fails to match, nothing deploys and the error says how to recover, so you can try an edit without reading the file first. Edits are never lossy: the pre-edit version stays restorable via revert_site, so to undo an edit, revert — don't hand-invert it. After visual changes, preview_site shows what actually rendered.

get_integrations

ChatGPT
Show a site's connections to other services' APIs (Pro plan) and how they last went: which secrets are set (never their values), the declared routes, actions, schedules (next run, last result, failures) and webhooks (URL, last event), and the latest 20 outcomes, including real page use. Read-only. Pass reference: true for the drivethrough.json format these are declared in, with two complete examples — read it before adding one to a site.

get_site

ChatGPT
Read back a deployed site: file manifest, file contents, drivethrough.json — and the site's version history. Use this to resume work on a site from an earlier conversation. Read the minimum you need: find locates text without returning file contents, manifest_only lists what exists, paths fetches only named files — a bare call inlines every text file, so reserve it for genuinely reading a whole small site. Versions: every deploy is a numbered version the platform keeps. history: true lists them with what each one changed (the map for revert_site), compare: {from, to} returns line diffs between two versions ("what did v9→v10 change?"), and version pins any read mode to a prior version instead of the live one. Modes are exclusive per call — compare wins over history, history over find/manifest_only. Entries come back deploy_site-compatible ({path, content, encoding}); binary files are listed but only inlined when named in paths. For small text changes you may not need this at all — edit_site applies find/replace to the deployed files directly.

list_sites

ChatGPT
List the authenticated account's sites with their addresses, visibility, and status. Pass include_deleted to also see recently deleted sites (recoverable for 30 days via restore_site).

manage_domain

ChatGPT
Attach or detach a custom domain the user already owns (paid plans). "attach": connect the domain to the site — returns the exact DNS records to add; afterwards use check_domain {action: "connect"} for a one-click registrar link and check_domain {action: "status"} to poll until active. "detach": remove the domain from the site. The site keeps its drivethrough.site address throughout.

preview_action

ChatGPT
Show the exact request one of a site's declared actions would send for a sample row (Pro plan) — method, URL, headers and JSON body, with every secret value redacted — or why it can't be built (a secret not set, a bad URL). Nothing is sent, stored or charged. Check that the {{field}} values landed where they should. To see a real run, ask the user to use the page once (submit the form, press the button, load the page), then read get_integrations' action_log.

preview_schedule

ChatGPT
Show what a site's declared schedule would send on its next run (Pro plan), with every secret value redacted: for "rotate", the row that comes next and the request its action would send; for "pull", the GET it would make and the type and map its response would fill. Nothing is sent, stored or charged, and the rotation doesn't move. get_integrations shows when it next runs and how its last run went.

preview_site

ChatGPT
See a deployed site the way a visitor does: renders the page in a real browser server-side and returns a screenshot image you can look at directly. You have no browser of your own — this is your only view of rendered results, so use it to verify visual work (layout, styling, animations, responsive behavior) actually shipped correctly instead of assuming it did, and to eyeball a prior version before reverting to it. Works on private sites; nothing becomes public. Takes a few seconds — look once after a coherent batch of changes, not after every edit. Animations: the capture happens at page load; pass wait_ms to let one settle or reach mid-cycle.

preview_webhook

ChatGPT
Dry-run one of a site's declared webhooks (Pro plan): builds an event from sample field values, takes it through the same mapping and validation a real delivery gets, and returns the row it would store and the URL the other service must POST to. Nothing is stored, sent or charged. Real delivery is proven by the other service's own "send test event", then get_integrations (last event).

query_db

ChatGPT
Read the site's database as its owner (read-only — writes go through write_db). Same query surface the site's own pages use, so what works here works there. Every row is {seq, type, parent_seq, json, created_at, updated_at}: seq is the row number and its permanent identity (never reused, even after a delete), json is the document. Newest-first is the default and always free. Filtering, sorting and search need a matching entry in the site's "query" block in drivethrough.json — an undeclared query is refused with the exact line to add. As the owner you get a bounded 5,000-row scan instead of a refusal, marked "partial": true, so you can look at data you have not modelled yet; a visitor page gets the refusal.

restore_site

ChatGPT
Restore a deleted site within its 30-day recovery window. It comes back exactly as it was — content, data, visibility — minus guest access (share links stay revoked; create new ones). If the old name is taken, pass sitename to restore under a new name. (Undoing changes to a live site is different — that's revert_site.)

revert_site

ChatGPT
Return a site to a prior version, byte-exactly, in one call — the safe way to undo. When the user says "undo that" or "put it back how it was", use this; never reconstruct the old state by hand with inverse edits, which risks leaving the site neither old nor new. The platform redeploys the target version's exact stored files as a new version — history is preserved, so a revert can itself be reverted — and the response proves the restore: byte_identical: true means the new version's content hash equals the target's. Find the target with get_site {history: true} (each entry shows what that version changed), or use the version number a deploy/edit response reported. Undoing just one file of a multi-file change? Read that file at the old version (get_site {version, paths}) and deploy it with mode "patch" instead.

set_privacy

ChatGPT
Set a site's visibility to public or private. Privacy is a setting — nothing redeploys.

share_site

ChatGPT
Create a share link for a private site, or send a magic-link invitation by email. Anyone with the link can view; guests never make accounts.

write_db

ChatGPT
Write to the site's database as its owner: insert one row, import many, update, or delete (reads go through query_db). Rows are addressed by seq, the row number query_db returns. To change a few fields of a row, update with merge — only the fields that change, no fetch needed. Reserve json (wholesale replacement) for rewriting the whole document. To load a catalogue, use rows for a handful and rows_url for thousands — never loop insert, and never try to emit 100,000 rows yourself. Writes are validated against the types declared in the site's drivethrough.json (unknown types and mismatched fields are rejected, and a bulk import is checked in full BEFORE the first row is written, so it is all-or-nothing); pass validate: false only for a deliberate migration. Deleted and overwritten rows are gone for good — there is no version history for data, so read a row (query_db) before destructive rewrites you might need to undo. Deleting a row also deletes its children. Every write counts against the account's monthly write allowance, and an import larger than what remains is refused before anything is written.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/drivethrough"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/drivethrough)