site2mcp

Turn any website into an MCP server your AI agents can call

HAR-to-MCP generator for recorded website APIs. Export a browser session to OpenAPI 3.1, a typed Python client, and a standalone Model Context Protocol server.

Quick start · Why site2mcp · What it does · How it works · Sample output · FAQ · Docs

pipx install site2mcp

Or run without a persistent install: uvx site2mcp --help. Registry installs require the first release to be published. Until then, use the source checkout below.

Why site2mcp

You have a website session an agent needs to repeat, but no MCP server for its API.

• Record the actions you need in your browser, then inspect the inferred tools before running them.
• Generate OpenAPI, a typed Python client, and an MCP server from the same recording.
• Learn locally without contacting the recorded site. Optional CLI descriptions use sanitized metadata.
• Supply fresh credentials at runtime. Write tools stay hidden until you enable them.

Quick start

Install with Python 3.11+ and pipx:

pipx install site2mcp

To use uv instead, prefix each command with uvx, for example uvx site2mcp inspect session.har. For a source checkout, install the pinned dependencies with uv and make:

git clone https://github.com/harinaralasetty/site2mcp.git
cd site2mcp
make setup

Source installs expose the command at .venv/bin/site2mcp. Dependency installation needs network access. The tests and demo run offline against loopback only.

1. In Chrome, open DevTools, select Network, enable Preserve log, and use the app normally. Right-click the request list and choose Save all as HAR with content, or use the HAR export button. Some versions export sanitized HAR by default. Missing cookies or response bodies reduce what can be inferred.

2. Capture different IDs, optional fields, and pagination for the actions you need. Keep the raw HAR private.

3. Preview the recording and generate the server:

   site2mcp inspect session.har
   site2mcp learn session.har -o out --name 'My account' --describe none
   

4. Read out/README.md and supply the required environment variables or create out/.env with fresh credentials. Start the MCP stdio server:

   site2mcp serve out
   

If the page and API use different hosts, use the exact API hostname in both commands:

site2mcp inspect session.har --host api.example.com
site2mcp learn session.har --host api.example.com -o out --name 'My account' --describe none

To run the full offline loop from the source checkout:

make setup
make demo
.venv/bin/site2mcp inspect demo-output/session.har

The demo starts a local notes and tags app, logs in to that loopback app, records its requests, learns the API, validates OpenAPI, and calls the generated server through the official SDK's MCP stdio client. It also runs the generated typed client in a separate process, then shuts its server down. To explore the demo separately, run .venv/bin/python -m demo.app, then run .venv/bin/python -m demo.record in another terminal. The recorder only accepts loopback HTTP.

site2mcp serve out --allow-writes --rate 2 --timeout 15

{
  "mcpServers": {
    "my_site": {
      "type": "stdio",
      "command": "/absolute/path/to/site2mcp/.venv/bin/python",
      "args": ["/absolute/path/to/out/server.py"]
    }
  }
}

[mcp_servers.my_site]
command = "/absolute/path/to/site2mcp/.venv/bin/python"
args = ["/absolute/path/to/out/server.py"]

What it does

openapi.yaml uses JSON syntax, which is valid YAML 1.2, so generation needs no YAML dependency. GraphQL shares one OpenAPI HTTP operation with an x-graphql-operations list, while MCP exposes a tool for each observed name.

How it works

site2mcp reads a HAR locally, filters traffic to the selected host, redacts captured values, and groups observed requests into operations. It merges their schemas and writes the generated files. serve loads the generated manifest and calls the real site with credentials you supply.

Learning and inspection do not contact the recorded site. Optional --describe modes can contact a provider through an installed CLI; deterministic naming with --describe none is the default.

Sample output

Real output from make demo, trimmed to the verification lines:

Recorded 15 requests against loopback demo
Learned 9 tools from 15 entries
OpenAPI 3.1 validation: PASS
Default MCP tools: get_note, get_tag, graphql_list_notes, list_notes, list_tags
Real MCP read calls: 5 passed; hidden write call rejected
--allow-writes: 4 write tools exposed; REST and GraphQL writes passed
Generated typed client: PASS
Offline end-to-end verification: PASS

A real-site check on 28 October 2026 loaded a Chrome recording of Hacker News search with 44 requests. Selecting the API host with --host learned 2 tools. None of 7 credential-like values from the recording appeared in any generated file. This checks one recording, not every site or session.

FAQ

How do I turn a website into an MCP server? Record the actions in Chrome, export a HAR with response content, then run site2mcp inspect, site2mcp learn, and site2mcp serve. Supply fresh credentials before serving.

Does it send my cookies anywhere? Learning and inspection stay local and do not contact the recorded site; optional descriptions send only sanitized method/path metadata to a provider CLI. Serving sends the credentials you supply to the real site to perform tool calls.

Which sites work? Start with sites whose recorded requests expose JSON REST APIs or supported named GraphQL operations. Select the API host with --host when it differs from the page; multipart uploads, WebSockets, and streaming are unsupported.

Can an agent change data? Write tools are hidden unless you pass --allow-writes, and the typed client requires allow_writes=True. REST POST searches also need this flag; a site's GET endpoint can still have side effects.

Does the recording describe the whole API? No. Schemas, required fields, enums, and operations describe only the recorded samples. Record different IDs, optional fields, and pagination, then review the inference notes.

How is this different from mitmproxy2swagger or browser agents? site2mcp starts from a browser HAR and generates OpenAPI, a typed Python client, and an MCP server. It replays the observed API calls with supplied credentials instead of controlling the page.

Does it need an LLM or an API key? No. The default --describe none uses deterministic names offline. Optional --describe claude and --describe codex modes use installed CLIs and fall back when unavailable or unsupported.

Can I run it from npm? The npm wrapper launches the same pinned Python release through uvx or pipx. It still needs a Python tool runner and is available after the npm and PyPI releases are published.

Where this fits

Use site2mcp when a recorded website workflow needs reusable API tools for an MCP client. The OpenAPI output can also feed other API tooling, and the typed client works independently of MCP. For UI steps that are not API calls, keep using a browser tool.

Documentation

• HAR fixture provenance describes the synthetic browser fixtures.
• AI assistant summary lists commands and limits.
• npm wrapper describes the Python launcher.
• Changelog records releases.

Contributing

Use Python 3.11+, uv, and make. Install the pinned development environment, then run:

make setup
make test
make lint
make demo

The pinned official MCP Python SDK provides protocol handling and transports. HAR parsing, schema inference, redaction, generation, dotenv loading, HTTP requests, CLI parsing, and the demo use the Python standard library. The SDK has its own transitive dependencies. openapi-spec-validator and ruff are pinned development dependencies; uv.lock locks the resolved environment.

Report reproducible bugs through GitHub Issues. Use synthetic or reviewed, redacted captures in reports. Keep raw HARs and credentials private.

License

MIT

By Hari Naralasetty (GitHub · LinkedIn).