Apiway MCP

Run your Apiway account from your AI agent

The Apiway MCP connector gives ChatGPT, Claude, Claude Code, Cursor, Codex or any MCP client the same tools the Apiway assistant has inside the product: apps hosted by Apiway, your Gmail, tasks and booking links, email marketing, Lead Transfer, Instagram Comment → DM automations, reporting connectors, the assistant’s memory — and on the full connector, generation of images, videos and reels. 139 tools, one sign-in, no API keys.

Two connector addresses

Full connector

https://studio.apiway.ai/api/mcp

Everything below, including AI generation of images, videos and reels (spends Apiway credits).

Connector without AI media generation (for the Claude connector directory)

https://studio.apiway.ai/api/mcp/directory

The same tools except generate_image, generate_video, generate_reel, get_generation_status and list_models.

How to connect

ChatGPT. Turn on Developer mode in Settings → Security and login (paid plans), then open Plugins, press Add → Create custom MCP server, paste the full connector address above and sign in to Apiway. Apiway then sits in your ChatGPT sidebar: ask it to open Apiway and your apps, gallery and credits appear as cards right in the chat — open an app, jump into its editor, or press Change to keep building it with ChatGPT. The canvas opens full screen inside ChatGPT.

Claude (claude.ai and Desktop). Customize → Connectors → + Add → Add custom connector, paste one of the addresses above, then sign in to Apiway and press Allow in the window that opens.

Claude Code. Run the command below, then /mcp to sign in. Or install the Apiway plugin, which adds the connector and the Apiway skill: /plugin marketplace add apiway-ai/apiway-plugins.

claude mcp add --transport http apiway https://studio.apiway.ai/api/mcp

Cursor. Add the server to ~/.cursor/mcp.json (or the project’s .cursor/mcp.json); Cursor opens the Apiway sign-in on first use.

{
  "mcpServers": {
    "apiway": { "url": "https://studio.apiway.ai/api/mcp" }
  }
}

Codex. Add the server to ~/.codex/config.toml, then run codex mcp login apiway.

[mcp_servers.apiway]
url = "https://studio.apiway.ai/api/mcp"

Authentication

OAuth 2.1 with PKCE and Dynamic Client Registration — your agent registers itself, you sign in to Apiway and approve on a consent screen that lists what the connector can do. Access tokens last 30 days and refresh automatically; disconnecting the connector in your agent ends access. Each connector address is its own OAuth resource: a sign-in approved for the connector without generation cannot call generation tools.

What stays with you

Sending an email, a Telegram or Discord message, and deleting a mail folder need confirm: true — the agent sets it only after your explicit yes. Protected recipients are never sent to by an agent.
An Instagram Comment → DM automation is created switched off; switching it on, and the link its DM carries, are set by you in Apiway.
Opening an app to anyone with its link is switched on by you in Apiway; plans and payments change only in Apiway.
Payment accounts (Stripe and other money connectors) are never read through the connector.
Every feature keeps its own limits: plan, credits, Gmail quota, send limits.

Tools

Images, video and reels

Generate images, videos and reels with AI, spending your Apiway credits.

`generate_image` changes · outside Apiway	Generates an image with Apiway (Gemini): text-to-image, or an edit of the reference photos given in image_urls / media_ids. Spends credits from the person's Apiway balance and saves the result to their gallery. With get_cost=true it returns the cost without generating.
`generate_video` changes · outside Apiway	Generates a short video with Apiway (Google Veo / Omni Flash): text-to-video, or image-to-video from image_urls / media_ids. Runs in the background and returns a job_id; get_generation_status reports its progress and the finished video. Credits are deducted when the job starts. With get_cost=true it returns the cost without generating.
`generate_reel` changes · outside Apiway	Turns 2-10 photos into one finished, music-backed vertical Reels video; Apiway plans the shots, motion and stitching. Runs in the background and returns a job_id; get_generation_status with kind="reel" reports its progress and the finished video. Credits are deducted when the job starts. With get_cost=true it returns the cost without generating.
`generate_site_photo` changes · outside Apiway	Generates one picture for a picture place of a website's preview — a slot such as "hero.image", "services.2.image" or an own section's "slots.<section>.<key>" (also an empty place the page draws as «Place for a photo») — in the site's own style, from the words of its block, and saves it as a new preview version (it can be brought back in Versions; nothing is published). The picture is marked as generated on the site. Spends 20 credits from the app owner's Apiway balance, taken before the generation and returned if it fails. With get_cost=true it returns the cost only and generates nothing. Returns the new version's deploy id and number, the picture's address on the site and the cost.
`get_generation_status` reads	Returns the status of a video or reel generation job (from generate_video or generate_reel) by job_id and, once completed, its gallery id and a playable URL.
`list_models` reads	Lists the Apiway image and video generation models with their credit cost per generation (1 credit = $0.01).

Account, gallery and files

Read your credit balance and gallery, upload images, change your interface settings and organise the files Apiway keeps in your Google Drive.

`open_apiway` reads	Opens the person's Apiway workspace: their apps with live and preview addresses, the newest gallery images and videos, and the credit balance.
`get_balance` reads	Returns the signed-in person's Apiway plan and remaining credits (1 credit = $0.01).
`list_files` reads	Lists the files the person keeps in Apiway's Files app, from the newest — name, type, size, date and the page that opens each — with the total storage used. `search` keeps the files whose name contains it.
`list_gallery` reads	Lists the person's most recent Apiway gallery assets (images and videos) with playable URLs, optionally filtered by kind.
`upload_media` changes · outside Apiway	Stores an image in Apiway storage — from a public URL, a data: URI or raw base64 with its mime type — downscaled, and returns a reusable media_id. A media_id is accepted as an input image by the generation tools and as an attachment by pin_asset and the sending tools.
`customize_interface` changes	Changes the person's Apiway interface settings, the same ones as Account → Interface: hides or shows shell elements, sets the theme, desktop wallpaper, interface language, clock format and the corner of the account avatar, or resets everything to default. The account avatar itself cannot be hidden. Returns the resulting settings.
`manage_drive_files` changes · outside Apiway	Lists, creates folders for, moves and links the files Apiway keeps in the person's Google Drive (only files Apiway put there). Actions: list, create_folder, move, link. Returns folder and file names with Drive links. It does not delete or send anything.

Apps (App Factory)

Create, change, publish and delete the apps Apiway hosts for you, read their logs, errors, versions, usage and visits, and work their leads.

`list_code_apps` reads	Lists the person's Apiway apps: name, slug, preview address and whether each is published. Names the Apiway account the connection is signed in to.
`get_code_app` reads	Returns an app's details and a shell command that downloads its current code — with AGENTS.md / CLAUDE.md, BRIEF.md, SETUP.md and the Apiway design kit — into the current folder.
`create_code_app` changes	Creates a new app in the person's Apiway App Factory from a kit: blank, crm, website, telegram-bot, instagram-bot or custom-integration (without `kit` it returns the list of kits). The app starts with an empty brief: brief_step walks its questions, and nothing is built before the brief is approved. Returns the app's slug and addresses.
`get_setup_questions` reads	Returns the questions of an app's brief (like a studio's client brief) with their options and the presets each business type pre-fills. Answers are sent with submit_setup_answers.
`submit_setup_answers` changes	Saves the answers to get_setup_questions. Apiway turns them into BRIEF.md and a draft project (app.config.ts, the ready modules), downloadable with get_code_app.
`get_setup_answers` reads	Returns the brief the person approved (BRIEF.md with notes for the builder).
`get_app_kit` reads	Returns the current version of the Apiway design system, rules and SDK (apiway-kit/) and a shell command that refreshes apiway-kit/ in an app folder.
`start_preview_update` changes	Step 1 of updating an app's preview: returns an update_id and a one-line shell command that packs the app's root folder (without node_modules, .next, .env*) and uploads it; finish_preview_update then builds it. It changes only the private PREVIEW that the owner alone sees — not a release: the published app stays as it is.
`finish_preview_update` changes	Step 2 of updating an app's preview: builds the uploaded archive with its Dockerfile and switches the preview to it. Waits up to ~45 s and returns the status (still building → get_preview_update_status), or the build log on failure. It changes only the private PREVIEW that the owner alone sees — not a release: the published app stays as it is.
`get_preview_update_status` reads	Returns the status of a preview update started with finish_preview_update, waiting up to ~45 s for it to finish.
`list_app_files` reads	Lists the files of an app's current code (the preview's version) with their sizes. Apiway's own kit under apiway-kit/ is summed up in one line.
`read_app_files` reads	Returns the text of up to 20 files of an app's current code (the preview's version), up to 400 KB together.
`edit_app_files` changes	Applies a set of edits to an app's current code and updates its preview with the result — the same checks and build as start_preview_update. Each edit replaces one exact piece of a file (find + replace), writes a whole file (content) or deletes one (delete). All edits apply or none. Returns the preview's status, or the build log if it failed (then the preview keeps its previous version). Files under apiway-kit/ and .env files cannot be changed. It changes only the private PREVIEW that the owner alone sees — not a release: the published app stays as it is.
`report_progress` changes	Shows a progress line to the person in Apiway App Factory while an app is built ("Step 4 of 11: connecting the pipeline"). `plan` — the titles of every step, sent once — becomes a checklist on the person's screen: finished steps ticked, the current one marked, the rest ahead; `detail` says what is being done inside the current step. With done: true it marks the work finished and returns the message for the person. `built` lists the reusable parts written for this app (a web app's modules, an integration's blocks); Apiway's team reviews them as candidates for its library.
`publish_code_app` changes · outside Apiway	Publishes the current preview at the app's address, replacing the published version. Available on paid Apiway plans. Requires confirm: true.
`unpublish_code_app` changes or deletes · outside Apiway	Takes the published app off its address: it stops opening there, and forms and webhooks at that address stop working. The preview, the data, the versions and the domain stay; publish_code_app puts it back. Requires confirm: true.
`set_code_app_editor_agent` changes	Sets who makes the edits of the app in Apiway's editor: `own` — the person's own agent (edits wait in the Edits Pool), `apiway` — Apiway's own agent (it builds in Apiway, on a paid plan), `auto` — whoever built the latest preview version. Changes nothing in the app itself.
`list_code_app_versions` reads	Every version of the app: which one is in the preview, which is published, which did not start, which waits for permission to delete data.
`publish_code_app_version` changes · outside Apiway	Publishes one version from list_code_app_versions — a rollback or a roll forward. Available on paid Apiway plans. Requires confirm: true.
`decide_code_app_migration` changes or deletes	Allows or cancels a version whose database migration drops, deletes or renames data; such a version waits for this decision. `allow` runs the migration (requires confirm: true), `cancel` discards the version.
`set_code_app_access` changes	Sets who can open the published app: `owner` (only the person) or `workspace` (their Apiway team). `link` (anyone with the link, no sign-in) is switched on by the person in Apiway; for it the tool returns that place. `workspace` and `link` access require a paid Apiway plan; `workspace` requires confirm: true.
`set_code_app_data_access` changes	Sets which of the owner's Apiway data an app may use through the SDK: mail.threads (their emails with a client — subjects and dates), tasks (their Apiway calendar), notify (a Telegram message to them), connectors.read (reports from connected services), apps.connect (their other Apiway apps), accounts.read (companies found in their mail). Emails, SMS and AI are always available to the app. Granting a scope the app does not have yet requires confirm: true; removing scopes does not.
`set_code_app_env` changes or deletes	Stores secrets and settings for an app as environment variables (e.g. TELEGRAM_BOT_TOKEN); null removes one. The app restarts with them. Values are not shown back. DATABASE_URL, APP_URL, APIWAY_* and PORT are set by Apiway. Changing or removing a secret the app already has requires confirm: true.
`request_code_app_secret` changes	Returns a link to the app's page in Apiway where the person types a key or token themselves (e.g. TELEGRAM_BOT_TOKEN, STRIPE_SECRET_KEY) — the value goes straight into the app's encrypted secrets and stays out of the chat. Also says whether the key is already set. The key is added to the app's «Connections» card in Apiway, shown to the person after the build. `how_to` and `label` are shown to the person as plain text.
`preview_code_app_draft` changes	Puts the draft Apiway assembled from the approved brief (the kit plus its config — a bot's scenario, a site's site.config) on the app's preview as it is, with no agent involved. Returns the update id for get_preview_update_status. Nothing is published.
`rename_code_app` changes	Change the app's name and/or its address (<address>.apiway.app). The old address keeps redirecting for 30 days. Requires confirm: true.
`code_app_backups` changes or deletes	The app's database copies. action "list" (default) returns the daily copies (14 kept); "now" makes a copy; "restore" with backup_id returns the data to that moment, losing everything written after it (requires confirm: true).
`delete_example_data` changes or deletes	Deletes every row marked is_example = true in the app's database, and nothing else; rows without the mark are not touched.
`delete_code_app` reads	Returns a link to the app's page in Apiway where the person confirms deleting it themselves (the app then stops opening and leaves App Factory; Apiway support can restore it within 6 months). The tool itself deletes nothing.
`get_code_app_logs` reads	The app's latest log lines (server output, errors) — of the preview (default) or the published app.
`get_code_app_errors` reads	Returns the app's open errors — a failed build, the app not starting, errors inside it — with how often and where, plus the log, secret values removed.
`get_code_app_usage` reads	Per app: the database on disk, the kept copies, and the emails, SMS and AI it bought through Apiway in the period, with the credits spent.
`submit_app_brief` changes · outside Apiway	Creates an Apiway app (or uses an existing one by slug) from a brief document: the text in the person's words (links inside are read too) plus files — pictures, docx/pdf/txt/md, xlsx/csv, a zip — each placed after a paragraph. Apiway reads everything and its analyst writes a detailed spec and "Recommendations: how we'd do it". Returns the spec, the recommendations and the app's slug. Nothing is built until approve_app_spec.
`get_app_spec` reads	The spec and the recommendations Apiway's analyst wrote from the app's brief (with the person's edits), and whether it was already given to the agent. For a web app also its plans as a feature × plan matrix and the site's texts.
`approve_app_spec` changes	Turns the app's spec (optionally edited: a new text, the recommendations to keep — the ones left out are dropped; for an integration, its services as the person confirmed them; for a web app, its feature × plan matrix and the site's texts) into the agent's task: TZ.md, PLAN.md, BRIEF.md and REFERENCES.md in the app's draft. Site texts that break the writing checks (an empty word, a headline equal to its menu name, a line over its length, another product or a plan named, the product's own name missing, an invented figure) are refused with the list of places. Returns the task text; the code comes with get_code_app.
`get_code_app_bot` reads	For a Telegram-bot app: whether it has its own bot token, and the link that opens its preview on the shared Apiway test bot. For an Instagram-bot app: the person's connected Instagram accounts and which one the app answers. Also returns the wizard link in Apiway.
`connect_code_app_bot` changes or deletes · outside Apiway	Store the Telegram bot token from @BotFather as the app's secret, check the bot with Telegram and point its webhook at the app (the published app, else the preview). `token` may be the whole BotFather message. Pass token null to remove the app's own bot — its preview goes back to the Apiway test bot. Returns the bot's @username.
`bind_code_app_instagram` changes	Make an Instagram-bot app answer the Direct messages of one of the person's Instagram accounts connected to Apiway (connection_id from get_code_app_bot). One account answers in one app. Pass connection_id null to unbind. Messages come to the app's /webhooks/instagram; replies go through Apiway within Instagram's 24-hour window.
`get_code_app_bot_scenario` reads	The scenario of a Telegram- or Instagram-bot app as the person shaped it on the mock-up in Apiway: mode (classic or ai), greeting, menu buttons with their answers, the request and its steps (typed fields), tone, emoji, the default phone country, where requests go, broadcasts, reply from the notification. Also the AI assistant's settings, the brief's answers, whether the person approved it (approvedAt), how many facts the bot starts with, and the text of bot/scenario.ts that Apiway writes into the app.
`set_code_app_bot_scenario` changes	Replaces the scenario of a bot app with `scenario` (the shape get_code_app_bot_scenario returns) and records it as approved by the person. It is checked by the kit's own rules: at most 6 buttons (3 on Instagram), labels up to 25 characters, a request of up to 4 steps, typed fields, no broadcasts on Instagram. Returns the saved scenario and the new text of bot/scenario.ts; an app already built gets it in its code through the agent.
`set_code_app_bot_assistant` changes	Saves the AI assistant settings of a bot app: name, company, what it does, tone (friendly, formal, neutral), emoji, up to three voice samples, answer mode (auto — answers by itself from the knowledge base; review — every answer waits for the owner's OK), topics it may answer by itself, who takes over and how, the owner's special instructions, the daily limit of AI answers. Returns the saved settings and the text of bot/assistant.ts.
`suggest_code_app_bot_scenario` changes	Apiway's analyst designs a scenario for a bot app from the company brand and the brief's answers (what kind of bot, what clients write, where requests go) — the same as “Suggest another” on the mock-up. `different` asks for a menu unlike the current one. When the analyst is unavailable, the standard scenario for the mode comes back (by: default). Nothing is saved; set_code_app_bot_scenario saves.
`ask_code_app_bot` changes	Sends one message to a bot app's AI assistant as a client would, before the bot is live — the answer comes from what the bot will know (the company brand), by the same rules as the real bot. Returns the reply, the facts it relied on, and whether it would go to the client (send: true) or to the owner as a draft, with the reason (a number not in the facts, a handoff, the review mode).
`start_code_app_instagram_connect` changes	For an Instagram-bot app: a fresh 10-minute code for @Apiway_official_bot and its Telegram link. The person opens the link on their phone, the bot answers with a one-time button, they sign in to Instagram, and Apiway's page of the app asks “Is this your account?”. Returns the code, the link, the page, and the current status (the account waiting for a yes, the bound account, the checklist).
`get_code_app_analytics` reads	Returns the published app's visits (one per visitor a day), page views, pages per visit, leads and conversion for the period, visits by day, and top pages, sources (referrer or utm_source), devices and countries. Counted by Apiway at the app's address; the preview is not counted.
`list_code_app_leads` reads	Lists the leads the app's forms sent, the latest on top: id, form, name, email, phone, the fields filled in, source (utm, referrer, page), status (new, in_progress, won, lost), comment and date, plus where new leads go (Telegram, a Google Sheet) and the Leads panel link.
`update_code_app_lead` changes	Sets a lead's status (new, in_progress, won, lost) and/or its comment; the change is added to the lead's history. Returns the lead.
`delete_code_app_lead` changes or deletes	Deletes one lead of the app for good (a row already added to a Google Sheet stays there). Requires confirm: true.
`set_code_app_lead_delivery` changes · outside Apiway	Turns the Telegram message to the person about each new lead on or off, and sets the Google Sheet each new lead is added to as a row (a sheet link; empty string stops it). Rows are written with the person's Google account connected in Lead Transfer; returns an error line when it is not connected.
`get_code_app_ai_usage` reads	Returns the AI this one app used through Apiway in the period: credits, requests, average answer time, credits by day, a table per function (the label the app passes) with model kind, requests, credits and time, this month's credits and the app's own monthly limit.
`set_code_app_ai_limit` changes	Sets how many credits a calendar month this app may spend on AI (null removes the limit). Over it the app's AI calls are refused until next month and the person gets a Telegram message; their other apps are not affected.
`get_code_app_domain` changes · outside Apiway	Returns the app's custom domain (e.g. www.example.com), its status (pending_dns → pending_cert → active, or failed with a reason), the CNAME record to add at the DNS provider, and the Domain panel link in Apiway. With check: true it re-checks DNS, the certificate and whether the site opens before answering.
`set_code_app_domain` changes · outside Apiway	Connects the published app to the person's domain: example.com becomes www.example.com (the apex redirects to www), a subdomain like shop.example.com is used as given. Replaces the app's previous domain. Returns the CNAME record to add and the status; the app's Apiway address redirects to the domain once it is active. Requires confirm: true.
`remove_code_app_domain` changes or deletes · outside Apiway	Disconnects the app's custom domain: the app goes back to its Apiway address and restarts. The DNS record at the provider is left as is. Requires confirm: true.
`list_code_app_edits` reads	Returns the app's open edits (screenshot, note, page, desktop/mobile, element slot), the recent rounds (pools) sent to an agent, each with its id, number, the name the person gave it (null when none) and each edit's outcome (done with an AFTER screenshot, not done, accepted, sent back) and report line, how many new client notes wait, and which agent the edits go to (apiway, external or unknown).
`add_code_app_edit` changes · outside Apiway	Adds one edit to the app's open edits: a note, a screenshot of the preview (a public image URL or a media_id from upload_media), or both, the page path, desktop or mobile, and an optional element slot id. Returns the edit's id.
`send_code_app_edits` changes	Sends the open edits (or only the given ids) to an agent as one round: the round goes to the archive and a new empty list opens. agent 'apiway' starts Apiway's own agent, which answers with a plan and waits for Start (spends the person's credits); 'external' returns the prompt for the person's own agent, which asks for an AFTER screenshot and a one-line report per edit. Without agent, the one that builds this app is used. Requires confirm: true.
`review_code_app_edits` changes	Acts on a sent round of edits: plan (save your plan of the pool — the owner reads it in the pool's report; round_id optional, the latest pool by default), start (Apiway's agent carries out its plan; spends credits), accept (the given edit ids), accept_round (every edit of the round with an AFTER screenshot), or redo (one edit id with a comment — it goes back into the open edits linked to the original). Requires confirm: true for start.
`rename_code_app_edits_pool` changes	Changes the name of a sent pool (round) of the app's edits — what the person sees on the pool's page and in the list of all pools. round_id comes from list_code_app_edits; without it the latest pool is renamed. An empty name gives the pool its own name back (Pool N). Returns the name now shown.
`list_code_app_client_notes` reads	Returns the notes clients sent through the app's review invites, the new ones at the top, each with its screenshot, note, page, author and state (new, taken into edits, rejected with the reply). Client notes reach an agent only after they are merged into the edits (merge_code_app_client_notes).
`merge_code_app_client_notes` changes	Moves the given new client notes into the app's open edits (the client sees 'In work'), or with reject_reply rejects ONE note (the client sees 'Rejected' and the reply). With send: true the open edits then go to the agent like send_code_app_edits (requires confirm: true).
`code_app_review_invites` changes or deletes	Lists, creates or revokes the links that let a client review the app's preview without an account (they give only a name, add notes by screenshot, and see statuses). create returns the link once; list shows who opened it and when; revoke stops a link at once (the preview frame within two hours).
`code_app_recommendations` changes or deletes	Lists what was recommended for the app, adds up to 3 recommendations, hides one, or switches recommendations on or off for the account. A recommendation needs `title`, `seen` (what was seen and where), `impact` (what it costs the owner if left alone) and `change` (the concrete change); one without them, or a general practice with nothing of this app in it, is refused with the reason. A recommendation the owner hid is not saved again.
`code_app_advisor` changes or deletes	The advisor of an app, as the lamp in its editor: list (what is broken, warnings, the steps to publish and connect a domain, recommendations — each with what it is and what happens if it is left), hide (a note that is a false alarm, by id), take (an agent's recommendation rec:<id> is being worked on), put_back (the preview goes back to the last version that built, after the owner's own edit failed), check (ticks or unticks step `id` of the path to a finished product — `path` in the list; `done` false unticks).
`apiway_guide` reads	The reference for App Factory: without a topic, the table of contents (each function with the words people use for it); with a topic id, that function's record — what it is, the tools in order, what the person does themselves, the screen in Apiway.
`list_site_styles` reads	Returns Apiway's ready website styles to choose a look from: up to eight that suit the business described in `business` (its trade's own styles, then the universal ones), or the whole gallery with `all`, each with its id, name, mood, a picture and a live demo page. A style is applied with set_site_style_reference (kind ready).
`brief_step` reads	Walks an app's brief one question at a time, in the order of Apiway's own brief screens. For a website: the screens of its brief — new or refresh, the person's own site, the language, the business, the reference (with the gallery of ready styles), how close to it, colours, font, the content or the pages to redesign, requests and contact, wishes, the summary. For every other template: its own required questions (a web app's product and plans, a CRM's business, process and team, a bot's job and greeting, an integration's flow). Returns the next step that still needs the person — the question, its options and how the answer is saved — with the steps already answered, or says the brief is complete and what approves it.
`code_app_preview` changes	The preview of an app: state (awake, waking or asleep), wake (starts a sleeping preview), screenshot (a PNG of one page as the owner sees it, desktop or mobile), pages (every page of the preview, grouped, with what each says about itself), style (a website's style passport: colours, fonts, section variants).
`code_app_plan` changes or deletes	The app's plan — one document with what was decided, what is done, what was turned down and what is open; the owner reads it in Apiway. read returns it; note adds one dated line to a section (decided, done, rejected, open); replace corrects one exact piece that occurs once.
`site_brief_action` changes or deletes	Runs one action of a website's brief, the same ones its screen has: goals, services, services-tidy, business-draft (suggestions from what is known), palette, logo, logo-palette, style, style-clear, page-add, classify, assets (include or exclude imported pictures), folder, own-example, reference-recapture, copy, share (a link to fill the brief), reset (clears the brief). `args` carries that action's own fields. Requires confirm: true for reset and share.
`code_app_data_requests` changes or deletes	What an app has asked to use of its owner's Apiway data and why: list (the pending requests), decline (drops the request for one scope; the app goes on without it). Allowing is set_code_app_data_access.
`reorder_code_apps` changes	Sets the order of the person's apps on the App Factory page: `slugs` in the new order; apps not named keep their place after them.
`code_app_setup` changes	Two choices of an app's setup: builder (who builds it after the brief: apiway, claude, codex or cursor) and bot_brand (the brand profile a bot speaks for — its id from the Branding app, or empty to clear).
`code_app_version_action` changes or deletes	Acts on an app's versions: preview (an older version, by version_id from list_code_app_versions, becomes the preview again; the published app is not touched), retry (an interrupted or failed build of version_id runs again), update_core (a website on an older site core gets a new preview version with the fresh core).
`code_app_build` changes or deletes	Apiway's own agent building this app (the editor's «Ask the agent»): status (the latest run: running, done, stopped, failed or limit, its question to the person, credits spent), start (it builds or changes what `prompt` says; paid in the person's credits), stop (the running build stops). Requires confirm: true for start.
`update_code_app_edit` changes or deletes	Acts on the app's OPEN edits: attach (one more picture to edit `id`: image_url or media_id), detach (removes picture `shot` from edit `id`), note (new text for edit `id`), delete (edit `id`; cannot be undone — requires confirm: true), reorder (`ids` in the new order), prompt (the line that starts the person's own agent on a sent pool, by round_id).
`list_code_app_skills` reads	Returns the skills available for the app's kit — ready tasks such as moving the content from an old site, translating the site, rewriting its tone, checking the phone version, copying a reference's design. Each has an id, a title, its stage, when it is needed, what the person gets, how long it takes, and its questions (id, text, type choice / text / url / file, options, default, optional).
`get_code_app_skill_task` reads	Returns the complete task of one skill for this app with the given answers: the app's header (name, slug, preview, how to get the code), the skill's instructions with the answers in, the rules learnt from earlier edits, and how to finish (update the preview, report_progress). Answers go by question id — a string, or a list of strings for a multiple choice or a file question (file links or names). An unanswered optional question is left out of the task; a missing required answer is named in the error. Nothing is started or changed.
`get_site_brief` reads	Returns a website app's brief: the road (update or new), goals, style passport, content import status, the site map with each page's main and supporting search queries, the generated site config (site-core SiteConfig), its own-content share and the publish checks.
`set_site_config` changes	Replaces the website brief's site config (site-core SiteConfig, validated) with the given one, or with regenerate: true rebuilds it from the brand, the answers, the collected content, the style and the site map. Before the brief is approved only; the approved config is written to site.config.ts at assembly.
`set_site_style_reference` changes · outside Apiway	Sets the style passport of a website brief: kind default (Basic minimalism), ready (one of Apiway's ready styles by its id), own (the brand's own site and logo), or reference with one site link. From a reference only design tokens are taken — colours, fonts from the site-core table, radii, rhythm, section variants — none of its texts, photos or logos. An unreadable link comes back with switchedToShot: true (a screenshot is then added on the Style screen).
`start_site_content_import` changes · outside Apiway	Starts the background import of the person's own content for a website brief: the brand, a full crawl of their own site (up to 100 pages, photos in full size, videos, embeds, PDFs), a Google Drive / Yandex Disk / Dropbox folder. It needs rights_confirmed: true — it stands for the person's own confirmation that the site and files are theirs, and it is stored as their consent with its text. Returns the import id; get_site_content_import reports its progress.
`get_site_content_import` reads	Returns the website brief's content import: status (running / done / failed), counts of photos by place (hero, works, team, other), videos, embeds, PDFs, quality marks, and the plain messages about limits.
`get_site_sitemap` reads	Returns the site map of a website brief: pages (home, services, a page per service, portfolio, prices, contacts), each with its main search query, 3–5 supporting queries and the search volume when checked, plus the old→new 301 map of the update road.
`set_site_sitemap` changes	Replaces the website brief's site map with the given pages (a main query stays on one page; repeated queries are dropped), or with regenerate: true plans it again from the brand's services, the niche and the city. The site config is rebuilt afterwards from the new map.
`set_site_redesign_pages` changes · outside Apiway	Sets which pages of the person's current site the initial redesign takes (the “What we'll redesign” screen): up to 10 addresses of that same site; pages not read yet are read for their titles and texts. The old site's legal pages (privacy, terms, cookies, offer) are always taken on top. Returns the pages picked and the legal pages found.
`set_site_brief_answers` changes · outside Apiway	Saves answers of a website brief: the road (new — a site for a new company; update — a redesign of the person's own site, with own_site_url and rights_confirmed: its pages and photos are then collected), the site's languages (the main one leads the list), the business (its name, what it does, its services), the email requests go to, the copy degree (fidelity 1–10 — how closely the site follows its reference: 9–10 exact, 6–8 close, 3–5 its character, 1–2 the mood only; the reference's texts, photos and logos stay out at every degree), the company's country (ISO code; confirmed: true lets the legal pages name its laws and sets the site's currency) and the person's wishes. Returns the saved values.
`set_landing_brief` changes · outside Apiway	Saves answers of a landing page's brief on a website app and puts the app on the landing road (one page that sells one offer). previous_landing_urls (with rights_confirmed) are read and analysed: what is sold, the problem, the client, the result, the price, the reviews, the page's photos and what the page lacks — the answers not given here are filled from that read. Also saves the offer in the person's words, video links, reviews (text, author, video link), whether Apiway generates pictures for blocks left without one (paid from the account owner's credits per picture made) and what the opening screen leads with. Returns the brief's landing answers, the read of each previous landing and the price of a generated picture.
`list_site_slots` reads	Returns the elements of a website's preview that the visual editor can change, each by its slot — the path of its content in site.config.ts (hero.title, services.2.image, slots.<section>.<key>) — with kind (text, button, image, item = a card of a list) and current value, plus the home sections in order with hidden ones, and the preview version the slots belong to.
`edit_site_slots` changes	Applies visual-editor ops to a website's preview and saves them as a new preview version (it can be brought back in Versions; nothing is published). Ops: text (slot, value), image (slot, src — https or /content/<file> of the site), focus (slot, x, y in %), move (slot, target, after — a card within its list or a home section), duplicate, remove, hide (home section, hidden). base_version defaults to the current preview version; a different one means the site changed and nothing is written. Returns the new version's deploy id and number (its build progress is what get_deploy_status reports).

Mail

Search and read your connected Gmail, see mailbox counters, prepare drafts, and manage Apiway mail folders, projects and notification settings.

`search_mail` reads · outside Apiway	Searches the person's connected Gmail with Gmail search syntax (from:, to:, subject:, in:sent, has:attachment, after:/before:). Accepts up to 6 queries at once. Returns matching threads with subject, snippet, date, participants and an Apiway URL.
`read_thread` reads · outside Apiway	Reads the last messages of a mail thread by thread id or Apiway thread link. Returns the subject and up to 6 messages with sender, date, whether the person wrote it, and text.
`mailbox_stats` reads	Returns the mailbox's live counters: unread in Main, threads awaiting the person's reply, and unread per custom folder. Counts are capped at 100; "unknown" means the counters are still warming up.
`propose_email_draft` reads	Prepares an email draft — subject, plain-text body and, for a new letter, recipient addresses — with AI typography (long dashes, guillemets) removed. Returns the draft; nothing is sent and nothing is created in Gmail.
`manage_mail_folders` changes or deletes	Manages the person's Apiway mail folders and projects. Actions: list, create (optionally as a project), rename, set_parent, add_rule (sender, domain or subject condition that gathers matching mail), archive, restore, delete. Nothing is moved or changed in Gmail itself.
`mail_settings` changes	Mailbox settings from the account menu. notifications_get / notifications_set read or change the global notification rule (desktop banner, sound, which sound, banner detail). automations_list lists where the mailbox forwards mail. billing_get reads the plan and credit balance (read only).
`project_mail_rules` changes	Lists, adds or removes the conditions (sender, domain or subject) that decide which letters appear in one mail project. It changes that project's own folder only.
`project_notifications` changes	Lists the Telegram chats and Discord channels connected in Apiway Mail automations, and attaches or detaches one mail project so its letters are forwarded there. It does not create a destination; with none connected it returns setup steps.

Sending messages

Send email, Telegram and Discord messages from your accounts — each send only with your explicit yes.

`send_email_message` changes · outside Apiway	Creates a Gmail draft (action=draft, default) or sends an email (action=send) from the person's connected Gmail. Files are delivered as one Apiway share link (default) or as attachments. Protected recipients are held for the person to send by hand. Returns the status, message and thread ids, and filesUrl when a link was made.
`send_telegram_message` changes · outside Apiway	Sends a text and optional files from the person's connected personal Telegram account to @usernames, @channels, numeric chat ids or contact names found in that account's chats. Per-recipient send limits apply. Returns the result per recipient.
`send_discord_message` changes · outside Apiway	Posts a text and optional files to Discord through a destination connected in Apiway Mail automations, or through a Discord webhook URL. Returns the Discord message id and the destination name.

Tasks, calendar and workspace

Create tasks, hand out your booking links, search your workspace and read where projects stand.

`create_task` changes	Creates a to-do on the person's own task lane in Apiway Calendar, with an optional due date (a date without a time becomes 09:00). Returns the task id, title and due date.
`booking_link` reads	Lists the person's booking pages in Apiway Calendar with title, duration and public URL, optionally filtered by match. It does not create or change a page.
`search_workspace` reads	Searches what is already stored in Apiway — tasks, agreements, points in Room chronologies and mail threads — by a few words. Each hit has a link that opens that exact block, plus the link of the letter it came from. It does not search the mailbox.
`read_project_status` reads	Returns where a company, project or work chat followed in the Apiway CEO feed stands: its stage, what needs attention (overdue tasks, clients waiting on a reply, agreements to confirm), per-conversation summaries and the latest events, each with a link. An empty name returns every followed track.

Email marketing, leads and Instagram

Write email campaign and sequence drafts, set up your sending domain, read which countries opened a campaign, manage Lead Transfer and Instagram Comment → DM automations (switching them on stays with you).

`compose_email` changes	Composes a marketing email from links, a short brief, an optional photo and brand fields, lays it out with the Apiway email builder, and saves it as a draft campaign (or updates draftId). Returns subject, html, previewUrl, builderUrl and draftId. Nothing is sent.
`save_email_draft` changes	Saves complete email HTML as a draft campaign in Apiway Email Marketing, or updates the draft given by draftId. Returns previewUrl, builderUrl, campaignUrl and draftId. Nothing is sent.
`email_sequence` changes	Email Marketing sequences. action=context returns the account's contact lists, existing sequences and saved brand. action=save lays out every letter of a sequence with the email builder and stores it as a draft sequence that is switched off, or updates sequence_id. Returns sequenceId, editorUrl and a preview URL per letter.
`email_domain_setup` changes · outside Apiway	Connects a sending domain for Apiway Email Marketing. action=status reads the domain's DNS records and what is already live, action=add adds the domain, action=check re-checks DNS. Optional provider = the domain provider the user named. Returns records (type, name, value, live), the next record to add, the DNS provider with a direct link to its DNS page, step-by-step instructions and official help pages, and a one-click connect URL where the provider supports it.
`manage_brands` changes	action=list returns the account's own brands (id, name, is_default, parent_brand_id) and Apiway's ready-made brands (read-only). action=copy creates a new brand of the account from a ready-made brand or from one of the account's own brands and returns it; the copy keeps following the ready-made brand's style for every field nobody changed.
`campaign_geography` reads	Returns the countries recorded on opens of one Email Marketing campaign. Each country has a code, an English name, an open count and its share of opens. Opens with no country are returned as untiedOpens.
`extract_email_brand` reads · outside Apiway	Reads one web page and returns its brand identity for an email: company name, description, tone, colours, fonts and type scale, button shape, an email-ready logo with its aspect ratio, hero images, social links, legal address and, on store pages, product cards (title, price, image, URL). Values the person saved in Apiway Branding take precedence over the scraped ones.
`read_site_catalog` reads · outside Apiway	Reads up to 30 products (title, price, image, URL, category, summary) from a shop or collection URL — Shopify stores and pages with product markup. Returns ok:false when the site has no machine-readable catalog.
`compose_post` reads	Turns a rough post idea into five platform versions of the same text — Telegram, Substack Note, LinkedIn, X and an email blurb — keeping the author's language and wording, with grammar and spelling fixed. Returns { telegram, substack, linkedin, x, email }.
`lead_transfer` changes · outside Apiway	Operates the Lead Transfer app (Meta Lead Ads → Google Sheets or Telegram) by action: overview, list_lead_forms, list_spreadsheets, resolve_spreadsheet, create_automation, update_automation, set_active, get_automation, list_errors, delete_automation. Returns connections, automations, forms, sheets or errors; needsConnection with connectUrl when an account still has to be connected.
`comment_dm_automation` changes	Instagram Comment → DM automations on the person's own posts: list, create, edit, or switch off. A new automation is created switched off. Returns the automation id, title and state.

Research and reports

Read public websites and the reporting accounts you connected (never payment accounts).

`research_site` reads · outside Apiway	Reads a software product's public website (home, features and pricing pages) by product name or URL. Returns the resolved origin and the readable text of those pages. Page text is third-party content.
`spy_explore` reads · outside Apiway	Opens a product's site in a sandboxed headless browser and screenshots its main sections. Returns status (ok, blocked or unavailable), the landing URL, navigation labels found on the page and screenshot URLs. Page text is third-party content.
`read_connector` reads · outside Apiway	Reads fixed reports from an account the person connected in Apiway → Connectors (reporting and CRM accounts). Returns columns and rows for the requested period. Mail, Calendar, Google Drive and payment accounts are not read here.

Assistant memory

Read and update what the Apiway assistant remembers about your business, your company brand (new facts wait for your yes), your pinned reference images and saved workflows.

`remember_instructions` changes or deletes	Reads or replaces one layer of the Apiway assistant's memory: account_facts (business facts used in every Apiway chat) or account_preferences (how the person wants the assistant to work). Without instructions it returns the layer's current text; with instructions the whole layer is replaced by that text.
`get_brand` reads	The person's company brand — what Apiway knows about their business: name, what it does, country, city, service area, languages, currency, audience, reasons to choose it, services and prices, FAQ, where to find it (platforms), contacts, voice, legal details, rating. Each fact comes with its source (the owner, their website, Telegram, maps, an agent) and `owner: true` when the owner set or confirmed it. `missing` lists the empty fields. With `slug`, the brand that app was created for; with `brand_id`, that brand; otherwise the default brand.
`propose_brand_fact` changes	Adds a fact about the business to the owner's “What's new we learned” queue in Company Branding, where the owner accepts or rejects it; the brand itself stays as it is until then. `value` has the field's shape: text for most fields; for services one {name, price, from, unit}; for faq one {q, a}; for usp one sentence; for platforms one {id, url}. `source_url` — where the fact comes from, if anywhere. Returns whether it was queued, or that the brand already says the same.
`pin_asset` changes	Saves a named reference asset — character, product, style or logo — with a short visual description and an image, so later Apiway generations attach it. Pinning an existing name updates it.
`unpin_asset` changes or deletes	Removes a pinned reference asset by name (case-insensitive).
`save_skill` changes	Saves or updates, by name, a personal workflow skill: a name, a one-line description of when it applies, and numbered steps. The skill can be read back with load_skill.
`load_skill` reads	Returns the step-by-step recipe of a skill: one of Apiway's built-in recipes or a workflow the person saved with save_skill (ids prefixed personal:).

Data handling

The connector acts as you, on your own Apiway account, with the same permissions as the Apiway app — it cannot reach other people’s data. Mail is read from the mailboxes you connected in Apiway (shared mailboxes are not available to agents), through the same Gmail limits as the app. What a tool returns goes to the agent you connected and is processed under that agent provider’s terms. Apiway handles your data under its Privacy Policy.

Support

Questions and problems: info@apiway.ai. Privacy: apiway.ai/legal/privacy-policy.