Hosted MCP Server

Install

claude mcp add --transport http answerline \
  https://mcp.answerline.dev/mcp \
  --header "Authorization: Bearer $API_KEY"

Example

# Any MCP client works; for clients that set their own headers:
#   URL:  https://mcp.answerline.dev/mcp
#   Auth: Authorization: Bearer $API_KEY

The hosted MCP server exposes one tool per engine plus a credits tool. Point a client at it with your API key, and the agent can ask ChatGPT or Gemini, or pull Google News, as a tool call.

The server is hosted, so there is nothing to deploy, and each tool call has the same pricing, validation and rate limits as a direct API call.

How the hosted server works

Each tool call is a REST API call: a tools/call for chatgpt is POST /v1/monitor/chatgpt with the tool arguments as the body, authenticated with your key. Nothing runs on your machine, and the same credits, concurrency limits and validation apply as for a direct API call.

The server speaks Streamable HTTP over POST and supports protocol revisions 2024-11-05 through 2025-11-25, plus 2026-07-28. Clients that accept text/event-stream receive tool calls as a stream with keep-alive comments, so long calls are not cut off by idle timeouts. GET and DELETE answer 405, and browser requests from origins not on the server’s allow list are refused with 403.

Get a key from the dashboard’s API keys page. The free plan includes 500 credits, once, and every engine tool can spend them: 36 ChatGPT calls at 13.7 credits, for example.

Client configuration

Claude Code

Add the server from the command line. --scope user makes it available in every project; the default local scope applies to the current project only.

claude mcp add --transport http answerline https://mcp.answerline.dev/mcp \
  --header "Authorization: Bearer $API_KEY" \
  --scope user

To share the setup with a team without committing the key, use a project-scoped .mcp.json at the repository root. Claude Code expands ${VAR} in url and headers, so each developer supplies their own key from the environment. The per-server timeout (milliseconds) raises the tool timeout for long engine calls:

{
  "mcpServers": {
    "answerline": {
      "type": "http",
      "url": "https://mcp.answerline.dev/mcp",
      "headers": { "Authorization": "Bearer ${API_KEY}" },
      "timeout": 360000
    }
  }
}

Structured results for search pages can be large. Claude Code saves tool output above MAX_MCP_OUTPUT_TOKENS (default 25,000 tokens) to a file, so either raise it (MAX_MCP_OUTPUT_TOKENS=50000 claude) or ask for less data, for example by leaving include.rawResponse off. Source: Claude Code MCP documentation, checked 2026-09-17.

Cursor

Cursor reads .cursor/mcp.json in a project or ~/.cursor/mcp.json globally. Remote servers take url and headers, and ${env:NAME} interpolation keeps the key out of the file:

{
  "mcpServers": {
    "answerline": {
      "url": "https://mcp.answerline.dev/mcp",
      "headers": { "Authorization": "Bearer ${env:API_KEY}" }
    }
  }
}

Source: Cursor MCP documentation, checked 2026-09-17. A longer walkthrough is in asking AI engines from inside your editor.

Claude Desktop and claude.ai

Claude adds remote servers as custom connectors: open Settings, choose Connectors, then Add custom connector, and enter a URL (MCP remote server guide, checked 2026-09-17). The dialog takes a URL rather than a header, so use the path form:

https://mcp.answerline.dev/sk_your_key_here/mcp

Anyone who sees that URL can spend your credits. Create a dedicated key for the connector so you can revoke it on its own from the dashboard; a revoked key stops working within a minute.

Other clients and your own agents

Any client that supports Streamable HTTP works with the header form. Clients configured with an mcpServers JSON file generally accept the same url and headers shape as Cursor. For a client that only takes a URL, use the path form.

To check connectivity without a client, send JSON-RPC directly. A plain JSON POST is treated as a pre-2026 client:

curl -s https://mcp.answerline.dev/mcp \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Tools

tools/list only lists the engines currently served, so today it returns chatgpt, gemini, copilot, aimode, google, google_news and credits. Perplexity and Grok are paused for now and coming back soon, and their tools return with them. Each engine tool’s inputSchema is the endpoint’s request schema from the OpenAPI document with references inlined, so every option on the engine pages is available as an argument: include.markdown, include.searchQueries on ChatGPT, and hl and pages on Google News.

Top-level “either of” rules (such as country or gl) are removed from the published tool schema, because several MCP clients reject them, but the API still enforces them. A call missing both comes back as a validation error the model can read and correct.

Tool results

A successful result’s text content is the API’s JSON response, {"success": true, "result": {...}} for engines and {"remaining", "perCycle", "cycleResetsAt"} for credits. The result’s _meta carries response headers such as x-ratelimit-remaining, x-credits-remaining and x-request-id.

Failures do not raise protocol errors. A non-2xx answer or a transport failure comes back as a result with isError: true and the API’s error body, for example INSUFFICIENT_CREDITS or a validation error listing the invalid field, so the model sees why the call failed and can retry with fixed arguments or stop and tell you. The error codes are listed in authentication and errors.

Costs, limits and timeouts

Every engine tool call is a synchronous API call, priced at the engine’s credits plus 6.7, and on Google Search and Google News plus 35 per results page:

A call also holds one of your plan’s concurrency slots while it runs and can take up to five minutes. So:

1. Raise the client’s tool timeout where it is configurable (the timeout field in Claude Code’s .mcp.json, for example), so the client does not give up before the answer arrives.
2. Expect parallel tool calls to compete for slots. If an agent fires more engine calls at once than your plan’s concurrency allows, the extra calls can fail with CONCURRENT_LIMIT_EXCEEDED. Ask the agent to call engines one at a time, or raise the plan. See rate limits and concurrency.

The MCP server has no async-task tool. For recurring tracking of hundreds of prompts, use batches from a script or the TypeScript or Python SDK; tasks cost the engine price without the synchronous surcharge and are delivered by webhook.

Prompts that work well

Agents choose tools from their names and descriptions, so plain requests work. Specific instructions make sessions cheaper and easier to check:

• Name the engines and market: “Ask ChatGPT and Gemini, country US, what the best invoicing tool for freelancers is, and list every domain each cites.” This stops the agent calling every engine tool.
• Ask for sources, not prose. ChatGPT and Gemini results carry sources, and Google News carries newsResults. “Compare the cited URLs” gives output you can check against the raw results.
• Check the budget first: “Call credits, then run at most 10 engine calls” makes the agent reason about cost.
• Keep payloads small. Leave include.rawResponse off unless you need it; it inflates the context window without adding to the answer.

Example: competitor check inside a coding session

In Claude Code, with the server added:

Use the answerline tools. For each of "best headless CMS", "Contentful alternatives"
and "headless CMS for ecommerce", ask chatgpt and gemini (country US, one call at
a time). Build a table of which of Contentful, Sanity, Strapi and Storyblok is mentioned
and which domains are cited. Then write the prompts to prompts.json for our nightly job.

The agent makes six engine calls (78 credits: three ChatGPT calls at 13.7, three Gemini calls at 12.3), reads result.text and result.sources, and writes the file, which a script can then submit as a batch. For the reasoning behind this workflow, see MCP servers for agents and competitor AI answer monitoring.

Troubleshooting

The MCP server reference lists the endpoints and tools, and each engine page documents the arguments a tool accepts.

Other integrations