MCP endpoint online

MIYAIP AI Browser MCP

Crawler MCP BETA

Connect a real JavaScript browser to your AI client through MCP. Describe the goal in natural language, then let your agent browse, interact, extract data, and return screenshots or reports.

TransportStreamable HTTP

RuntimeReal JavaScript browser

NetworkMIYAIP proxy regions

Billing1 credit / browser task

Browser task console

Natural language → MCP → Real browser

READY

Agent request

Use miya_browser to open the product page, extract the first 20 items into a table, and attach a screenshot.

Natural languageThe AI client interprets the goal

MCP toolsStreamable HTTP with Bearer auth

Real browserJavaScript, interaction, and proxy routing

Useful outputData, screenshots, and reports

Task activity

https://www.miyaip.com/mcp

User-scoped MCP key accepted

Public page opened in an isolated browser session

Page content and interactive elements observed

Structured result and artifacts returned to the AI client

Outputs

Data

Screenshot

Report

TransportStreamable HTTP

Connect compatible AI clients to the remote MCP endpoint over the current HTTP transport.

BrowserJavaScript runtime

Run pages in a real browser when rendering, interaction, console inspection, or network checks are required.

NetworkMIYAIP regions

Use the MIYAIP proxy network for tasks that need an available regional route.

Usage1 task = 1 credit

A browser task consumes one crawler credit; individual MCP tool calls inside it are not each billed once.

Browser Capabilities

One browser layer for data and web workflows

Give an MCP-compatible AI client the browser primitives it needs while MIYAIP handles execution, session isolation, proxy selection, quotas, and artifacts.

Available

Structured Data Extraction

Open public pages and collect lists, tables, article text, links, or other structured fields.

Available

Interactive Automation

Search, paginate, click, type, scroll, and navigate multi-step public web flows.

Available

Web Testing & Debugging

Check text and elements, exercise forms, and inspect console errors or failed network requests.

Available

Screenshots & Artifacts

Capture visual evidence and return saved task artifacts alongside the agent result.

Available

Regional Web Access

Run eligible tasks through available MIYAIP proxy regions when a regional route is needed.

Available

Human Takeover

Hand control to the user for CAPTCHA, SMS verification, or another step that requires a real person.

Task Workflow

From an instruction to a browser result

The AI client plans and calls the tools; MIYAIP executes the browser session and returns observations and artifacts.

01
Describe the outcome
Name miya_browser, the public target URL, the goal, and the result format. Ask for confirmation before sensitive actions.
02
Call MCP tools
Your AI client connects over Streamable HTTP and iteratively selects the browser tools it needs.
03
Operate the page
The remote browser renders JavaScript, interacts with the page, and uses an eligible proxy route when needed.
04
Return the result
Receive structured data, screenshots, reports, or a short-lived takeover step when human input is required.

Three-minute Setup

Connect the AI client you already use

Create a personal MCP key, add the remote endpoint and Authorization header, then restart the client and verify the tool list.

1
Create an MCP key
Create a named key in the MIYAIP console and save the full value when it is shown once.
2
Copy the client config
Use https://www.miyaip.com/mcp with a Bearer key. Set a 180-second tool timeout where the client supports it.
3
Restart and verify
Fully restart the app or extension, open a new conversation, and confirm the miya_browser tools are available.

~/.codex/config.toml

[mcp_servers.miya_browser]
url = "https://www.miyaip.com/mcp"
http_headers = { "Authorization" = "Bearer miya_mcp_REPLACE_WITH_YOUR_KEY" }
tool_timeout_sec = 180

After saving: Fully quit and reopen Codex App, CLI, or the IDE extension, then start a new conversation.
Verify: Run codex mcp list or open /mcp and confirm miya_browser and its browser tools appear.

~/.claude.json or .mcp.json

{
  "mcpServers": {
    "miya_browser": {
      "type": "http",
      "url": "https://www.miyaip.com/mcp",
      "headers": {
        "Authorization": "Bearer ${MIYA_MCP_TOKEN}"
      },
      "timeout": 180000
    }
  }
}

After saving: Restart Claude Code after saving the HTTP server configuration and open a new session.
Verify: Run claude mcp list, claude mcp get miya_browser, or inspect /mcp in the session.

~/.cursor/mcp.json or .cursor/mcp.json

{
  "mcpServers": {
    "miya_browser": {
      "url": "https://www.miyaip.com/mcp",
      "headers": {
        "Authorization": "Bearer miya_mcp_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

After saving: Restart Cursor, enable the MCP server in settings, and open a fresh Agent session.
Verify: Check MCP settings or run cursor-agent mcp list-tools miya_browser.

User settings or .vscode/mcp.json

{
  "inputs": [{
    "type": "promptString",
    "id": "miya-mcp-token",
    "description": "MIYAIP MCP API Key",
    "password": true
  }],
  "servers": {
    "miyaBrowser": {
      "type": "http",
      "url": "https://www.miyaip.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:miya-mcp-token}"
      }
    }
  }
}

After saving: Start or restart the MCP server after entering the key through the secure prompt.
Verify: Run MCP: List Servers. If tools are stale, reset the cached tools and restart the server.

Also works with

Windsurf / Cascade

Configure serverUrl with an Authorization header, then refresh MCP in Cascade.

Cline

Use the streamableHttp server type and keep sensitive browser actions out of autoApprove.

Gemini CLI

Use httpUrl, a Bearer header, a 180000 ms timeout, and keep trust disabled for confirmation.

MCP SDK / Custom Agent

Connect with an MCP SDK over Streamable HTTP; do not treat /mcp as a normal REST JSON endpoint.

ChatGPT Desktop's Codex host can use the Codex MCP configuration. ChatGPT Web does not read your local config.toml and is not a direct static-key connection.

Claude Code can connect with the configuration above. Claude.ai custom Connectors require a standard OAuth flow, which MIYAIP does not currently provide for this static-key service.

Billing & Safety

Clear boundaries for every browser task

Keep credentials private, stay within permitted access, and leave human-only verification to the user.

Task-based billing

Starting one browser task consumes one crawler credit; the tool calls inside that task are not each charged one credit.
The MIYAIP account must have available crawler credits and AI Browser concurrency before a task can start.
A task can stop when its time or action limit is reached. End stale tasks and retry with a clearer goal when needed.

Access boundaries

Only public HTTP and HTTPS targets are eligible. localhost, private networks, cloud metadata, and protected addresses are blocked.
CAPTCHA or SMS verification requires human takeover; the service does not promise automatic bypass.
Use only pages and accounts you are authorized to access, and require confirmation before logins, form submission, downloads, or other consequential actions.

FAQ

Before you connect

No. One browser task consumes one crawler credit. The agent can call multiple browser tools inside that task without each call consuming another credit.

Fully restart the AI client or IDE extension and open a new conversation. Existing sessions often keep a cached tool list. Use the client MCP list command to verify the server.

No. Codex and ChatGPT Desktop's Codex host can use the Codex configuration, and Claude Code can connect. ChatGPT Web does not read local config, while Claude.ai Connectors need OAuth support that is not currently provided.

No. Ask the agent to create a human takeover step when CAPTCHA, SMS verification, or another human-only check appears.

No. The service accepts eligible public HTTP and HTTPS targets and blocks localhost, private addresses, cloud metadata, and other protected network resources.

No. Site policies, account state, page changes, network conditions, and human verification can affect the result. Give the agent a clear goal and handle blocked steps explicitly.

Ready to connect

Give your AI client a real browser

Create a user-scoped MCP key in the console, save it securely, and connect your preferred client.

Crawler MCP BETA

Natural language → MCP → Real browser

One browser layer for data and web workflows

Structured Data Extraction

Interactive Automation

Web Testing & Debugging

Screenshots & Artifacts

Regional Web Access

Human Takeover

From an instruction to a browser result

Describe the outcome

Call MCP tools

Operate the page

Return the result

Connect the AI client you already use

Create an MCP key

Copy the client config

Restart and verify

Clear boundaries for every browser task

Task-based billing

Access boundaries

Before you connect

Give your AI client a real browser