Skip to main content
The control plane speaks MCP over two transports, and both publish the same tool surface: the stdio one is a relay to the HTTP endpoint, so a tool you can call on one you can call on the other. What differs is authentication, statefulness, and which optional protocol features can physically reach you.

At a glance

Config blocks for both are in MCP config.

stdio: the CLI relay

phoneuse mcp --stdio (CLI 0.5.0 and later) gives a stdio-only client your cloud phones. It reads MCP messages on standard input, sends each one to https://mcp.phoneuse.com/mcp with your key, and writes the answers to standard output. Nothing is interpreted on the way through, so every rule on this page for HTTP applies: the key’s scopes decide which tools exist, and there are no progress notifications or human takeover prompts. The CLI refuses to send the key over plain http to anything but your own machine. Nothing but the transport writes to standard output, because standard output is the wire. Diagnostics go to standard error, which is where the startup line you see comes from.

HTTP

The endpoint is POST /mcp. It speaks JSON-RPC, in JSON response mode, and it is stateless. Stateless means a fresh server and transport are built for each request, and that leases travel as explicit parameters rather than living in a session. There is nothing to resume and nothing to tear down, which is why GET and DELETE on the same path answer 405 with an Allow: POST header. Two protections run on every request, and a client that trips either is refused:
  • Host checking. In hosted mode only the deployment’s public host is accepted. Locally only loopback hosts are.
  • Origin refusal. Any request carrying a browser Origin header is refused. Without this, a web page could rebind its own hostname to loopback and drive your device with no cross origin preflight standing in its way. Loopback binding stops callers on other machines; it does not stop this.
Authentication happens before anything else. Local mode may require a development token; a hosted deployment requires OAuth or an API key. See Authentication.

What stateless HTTP cannot carry

Two protocol features need a live bidirectional session, and this is the part worth reading before you design a loop around them. Progress notifications. An action blocks until the device commits. A client that sent a progress token would be told the action was dispatched and is awaiting device commit, but over stateless HTTP, and over the CLI relay in front of it, there is no channel for a mid request notification, so nothing arrives. The server does not fail the action over it: progress is a transport capability, never a promise the tool surface makes. Human takeover. Elicitation is a request from the server to the client, so it also needs a live session. Over stateless HTTP it never happens, and the caller sees a terminal outcome instead. The substitute for both is the same one, and it is not a workaround: pass an idempotencyKey with your action and use get_receipt to find out what happened. That path works on every transport, survives a lost response, and survives a restarted client. See Progress and takeover.

Choosing

Use stdio when your client can only spawn a process (Claude Desktop, Cursor): the CLI relay gives it your cloud phones over the hosted endpoint. Use HTTP for everything else: anything shared, anything remote, and anything with more than one caller. Whichever you choose, the calls you write do not change.