MCP Server

The WebToAppConvert MCP server is a hosted MCP server that connects any compatible AI coding assistant or agent directly to your WebToAppConvert account. Instead of opening the dashboard, you tell the AI what you want and it builds your Android app, checks status, and hands you a download link, all in a single conversation.

The server wraps the REST API as 11 native tools the AI can call. It runs on WebToAppConvert's infrastructure. Most clients connect directly using the URL and your API key. Claude Desktop requires a lightweight proxy (mcp-remote) because it only supports local processes — see the Claude Desktop section below.

Compatible clients

Any MCP client that supports hosted HTTP servers with custom headers works with this server. Verified clients:

What it unlocks

With the MCP server configured, you can ask the AI things like:

• "Build a debug APK for my restaurant website at restaurant.example.com."
• "Duplicate my template app, set the URL to https://client.com, change the name to 'Client App', and trigger a starter build."
• "How many credits do I have left? Is it enough for a professional build?"
• "Check the status of my last build and give me the download link when it's done."
• "List all my apps. Which ones haven't been built in the last 30 days?"
• "Assign my 'Production Key' signing key to the Acme Bakery app, then trigger a professional build."
• "I have 5 client apps that need a starter build. Build them all and report back when each one finishes."

The agent handles the full workflow: credit check, app setup, build trigger, waiting (using the server's own time estimate), and download URL. It keeps you informed at each step.

Prerequisites

• A paid or subscribed WAC account. Free-tier accounts cannot generate API keys. Make any credit purchase or start a subscription to unlock API access.
• An API key. Go to My Profile → API Access → Generate API Key. Copy the raw key immediately; it is shown only once.
• An MCP-compatible AI client from the list above.

Setup

VS Code Copilot

Create a file named mcp.json inside the .vscode/ folder of your workspace. VS Code prompts you for your API key once and stores it in VS Code's secret storage. The key is never written to disk in plain text.

{
  "inputs": [
    {
      "type": "promptString",
      "id": "wac-api-key",
      "description": "WebToAppConvert API key (starts with wac_)",
      "password": true
    }
  ],
  "servers": {
    "webtoapp": {
      "type": "http",
      "url": "https://api.webtoappconvert.com/mcp",
      "headers": {
        "X-API-Key": "${input:wac-api-key}"
      }
    }
  }
}

Save the file. VS Code prompts for your key the first time it connects. After that, the server appears as webtoapp in Copilot's tools list and is available in any Copilot Chat conversation in that workspace.

Cursor

Create or edit ~/.cursor/mcp.json for a global config, or .cursor/mcp.json inside a project folder for a project-scoped config:

{
  "mcpServers": {
    "webtoapp": {
      "url": "https://api.webtoappconvert.com/mcp",
      "headers": {
        "X-API-Key": "wac_your_key_here"
      }
    }
  }
}

Restart Cursor after saving. The server will appear in the tools panel.

Cline

Open the Cline extension in VS Code and click the MCP Servers icon. Choose Add Remote Server and enter:

• Server URL: https://api.webtoappconvert.com/mcp
• Header name: X-API-Key
• Header value: your API key (wac_...)

Cline stores the config in its own cline_mcp_settings.json file managed by the extension.

Windsurf

Edit ~/.codeium/windsurf/mcp_config.json (macOS/Linux) or %USERPROFILE%.codeiumwindsurfmcp_config.json (Windows). Note that Windsurf uses serverUrl, not url:

{
  "mcpServers": {
    "webtoapp": {
      "serverUrl": "https://api.webtoappconvert.com/mcp",
      "headers": {
        "X-API-Key": "wac_your_key_here"
      }
    }
  }
}

Restart Windsurf after saving.

Claude Code

Claude Code is the Anthropic CLI tool (claude). It supports HTTP MCP servers natively. Run this command in your terminal — it adds the server to your global config:

claude mcp add --transport http webtoapp https://api.webtoappconvert.com/mcp   --header "X-API-Key: wac_your_key_here"

The server is then available in all Claude Code sessions. To verify, run claude mcp list.

Claude Desktop

Claude Desktop (the GUI app) only supports local stdio processes — it cannot connect to HTTP MCP servers directly. The solution is mcp-remote, a lightweight proxy that runs as a local command and forwards traffic to the hosted server. No separate install is required; npx downloads it automatically on first use.

Edit claude_desktop_config.json:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%Claudeclaude_desktop_config.json

{
  "mcpServers": {
    "webtoapp": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.webtoappconvert.com/mcp",
        "--header",
        "X-API-Key:wac_your_key_here"
      ]
    }
  }
}

Fully restart Claude Desktop (quit and reopen — a new conversation is not enough). On first start, npx downloads mcp-remote and the webtoapp server appears in your tools. Note there is no space between X-API-Key: and your key value in the --header argument.

Any other HTTP MCP client

If your client isn't listed above but supports hosted HTTP MCP servers, use these connection details:

Verify it's working

After connecting, ask the AI: "Check my WebToAppConvert account balance." It will call the get_account tool and return your tier, credit totals, and tier limits. If you see your account data, the server is connected and working.

Available tools

The server exposes 11 tools grouped into four categories. The AI selects and calls them automatically based on your request. You never need to name a tool explicitly.

Account

Apps

Builds

Signing keys

Example workflows

Build an app from a template

The fastest agent workflow. First, create one well-configured "template" app in the dashboard. Set the icon, colors, signing key, and any desired features. Then ask the AI:

"Duplicate my template app (it's called Customer Template), set the URL to https://example-client.com, change the name to Example Client App, package name com.example.client, and trigger a starter build."

The AI will:

1. Call get_account to verify you have at least 50 credits for a starter build.
2. Call list_apps to find the siteId of "Customer Template".
3. Call duplicate_app to create a new app with the same icon, colors, and signing key.
4. Call update_app to set the URL, name, and package name on the copy.
5. Call create_build to trigger the starter build and report the estimated wait time.
6. Call wait_for_build repeatedly until the build completes, reporting progress after each check.
7. Call get_download_url to return the download link.

Check a build and download it

"What's the status of my most recent build? If it's done, give me the download link."

The AI will call list_builds to find your latest build, then get_build_status for its current state. If it's completed, it calls get_download_url and returns the link. If it's still running, it tells you the estimated time remaining.

Assign a signing key to an app

"Show me my signing keys and assign the 'Production Key' to my app 'Acme Bakery App'."

The AI will call list_signing_keys to find the keyId of "Production Key", then list_apps to find the siteId of "Acme Bakery App", then update_app to set build.signing.keyId on it.

Check credits before deciding what to build

"How many credits do I have? Can I afford a professional build for all my apps?"

The AI will call get_account (credits + tier), then list_apps (count your apps), calculate the total cost, and give you a clear yes/no with the math shown.

How waiting works

The wait_for_build tool is designed to work within MCP clients that enforce per-tool-call timeouts. Each invocation runs for up to ~25 seconds: it polls once, sleeps the API's recommended estimatedWaitSeconds interval (capped to fit within the window), polls again, and returns. If the build is still running when the 25-second window closes, the tool returns the current status and tells the AI to call wait_for_build again. The AI loops automatically until it gets a terminal result (completed or failed).

The polling interval is never blind. After each check, the API returns a fresh estimatedWaitSeconds value based on queue depth and how far along the build is. If the server says the build is 3 minutes away, the tool waits roughly 3 minutes before the next poll, not 5 seconds. As the build progresses, the interval shrinks automatically.

You see progress after each call. The last log entry from the builder ("Compiling resources", "Signing APK", etc.) is reported in the conversation so you know the build is alive.

Privacy

Your API key is stored in your local MCP configuration file (or VS Code's secret storage). It is sent as the X-API-Key header on each request to the hosted server, which forwards it verbatim to the WAC REST API. The hosted server is stateless: it creates no session, stores no data, and terminates after each request. The key is never logged.

The key is never transmitted to Anthropic or Microsoft or included in the conversation context they see.

Never paste your API key into the conversation. The tools accept zero key-related input. The key comes from your config, not from the AI's arguments. If you paste the key as a message, it becomes part of your conversation history.

Troubleshooting

Server doesn't appear in my client

Check that:

• The key value starts with wac_ and is at least 40 characters.
• The server URL ends in /mcp (not /api/v1 or any other path).
• The JSON in your config file is valid. A trailing comma or mismatched brace will silently break it. Use a JSON validator.
• VS Code Copilot: the file is at .vscode/mcp.json inside the .vscode folder of your workspace. The top-level key is servers (not mcpServers).
• Cursor: the top-level key is mcpServers. Use url for the server address.
• Claude Code: use the claude mcp add --transport http command. Do not try to edit config files manually.
• Claude Desktop: must use the mcp-remote approach — it does not support type: "http" or url keys. If the server disappears from the tools list after a restart, your config was reset because an unsupported format was used. Use the command/args format with npx mcp-remote as shown above.
• Windsurf: uses serverUrl as the key name, not url. This is a common copy-paste mistake when adapting configs from other clients.
• Cline: configure via the MCP Servers panel in the extension UI, not by editing a JSON file directly.

"unauthorized" error when calling a tool

Your key is present but invalid. Either it was revoked or the value was truncated when you pasted it. Go to My Profile → API Access, revoke the existing key, generate a new one, and update the config.

"insufficient_credits" when triggering a build

The AI will report the gap (e.g., "You have 30 credits but a starter build requires 50") and include a link to the billing page. Purchase credits there, then retry. The tool never auto-retries on a 402 response; credits don't appear by themselves.

Build is taking a long time

The build queue is processed by a single builder. If other builds are ahead of yours, the wait estimate may be 10+ minutes. wait_for_build handles this correctly: each call runs for ~25 seconds and instructs the AI to call it again if the build isn't done. The AI loops automatically until it gets a result. Just wait and watch the conversation for progress updates.

Reference

• REST API documentation: Developer REST API Reference
• OpenAPI specification: /openapi.json (OpenAPI 3.1, ingestible by Postman, Insomnia, and MCP tools)
• API keys: My Profile → API Access
• Purchase credits: Billing

Questions or issues? Email support@webtoappconvert.com with your key prefix (wac_a1b2c3d4), the tool name, and what error you saw.