[ Integrations ]

Give your agent the whole web.

One endpoint, six tools, and a config block for whichever client you already use. No SDK to install and nothing to run locally.

The endpoint

https://api.hydrafetch.com/mcp

A streamable HTTP MCP server. Authenticate with an API key as a bearer token, or let the client run the OAuth flow and sign in through the browser.

Get an API key

scrape

A URL to clean Markdown, links, or the page’s own structured data.

1 credit

map

Every URL on a site, discovered in one call.

1 credit

A web search whose results come back already scraped. One credit for the search, one more for each result it scrapes.

1 credit

extract

Typed JSON matching your schema, with per-field evidence.

5 credits

brand

Logos, palette, fonts and socials for a domain.

5 credits

usage

The workspace’s remaining credit balance.

Free

[ Clients ]

Claude Code

Scoped to your user, so it is available in every project. Swap --scope user for --scope project to commit it with one repo instead.

With an API key

Terminal

claude mcp add --scope user --transport http hydrafetch https://api.hydrafetch.com/mcp \
  --header "Authorization: Bearer $HYDRAFETCH_API_KEY"

Or sign in instead

Terminal

claude mcp add --scope user --transport http hydrafetch https://api.hydrafetch.com/mcp

# then run /mcp inside Claude Code and sign in

Cursor

Global, so every project picks it up. Use .cursor/mcp.json in a repo instead if you want it scoped there. Drop the headers block and Cursor runs the OAuth flow instead.

~/.cursor/mcp.json

{
  "mcpServers": {
    "hydrafetch": {
      "url": "https://api.hydrafetch.com/mcp",
      "headers": { "Authorization": "Bearer hf_your_key" }
    }
  }
}

Codex

Codex reads the key from the named environment variable rather than the file, so the config stays safe to commit.

~/.codex/config.toml

[mcp_servers.hydrafetch]
url = "https://api.hydrafetch.com/mcp"
bearer_token_env_var = "HYDRAFETCH_API_KEY"

Only on older builds that ignore remote servers

~/.codex/config.toml

[features]
experimental_use_rmcp_client = true

OpenCode

The global config, so it applies everywhere. A project root opencode.json overrides it. OpenCode detects the 401 and can run the OAuth flow on its own, so the headers block is optional.

~/.config/opencode/opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "hydrafetch": {
      "type": "remote",
      "url": "https://api.hydrafetch.com/mcp",
      "enabled": true,
      "headers": { "Authorization": "Bearer hf_your_key" }
    }
  }
}

Cline

Open the MCP Servers panel, choose Configure, and paste this into the settings file it opens. Cline keeps it in global storage, so it follows you across workspaces.

cline_mcp_settings.json

{
  "mcpServers": {
    "hydrafetch": {
      "type": "streamableHttp",
      "url": "https://api.hydrafetch.com/mcp",
      "headers": { "Authorization": "Bearer hf_your_key" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Windsurf

Windsurf calls the field serverUrl rather than url. Everything else is the same shape.

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "hydrafetch": {
      "serverUrl": "https://api.hydrafetch.com/mcp",
      "headers": { "Authorization": "Bearer hf_your_key" }
    }
  }
}

[ Frameworks ]

Or call it from your own pipeline.

These use the HTTP API rather than MCP. There is nothing to install: the API is plain HTTP with one response shape, so an integration is a function, not a dependency.

LangChain

A document loader that returns clean Markdown instead of the tag soup a raw HTTP loader hands your splitter.

hydrafetch_loader.py

import os, httpx
from langchain_core.documents import Document

def load(urls: list[str]) -> list[Document]:
    docs = []
    with httpx.Client(timeout=120) as http:
        for url in urls:
            res = http.post(
                "https://api.hydrafetch.com/v1/web/scrape",
                headers={"X-API-Key": os.environ["HYDRAFETCH_API_KEY"]},
                json={"url": url, "onlyMainContent": True},
            )
            data = res.json()["data"]
            docs.append(Document(
                page_content=data["markdown"],
                metadata={"source": data["finalUrl"], **data["metadata"]},
            ))
    return docs

LlamaIndex

The same idea as a reader, so pages arrive already stripped of navigation and boilerplate before they reach your index.

hydrafetch_reader.py

import os, httpx
from llama_index.core import Document
from llama_index.core.readers.base import BaseReader

class HydrafetchReader(BaseReader):
    def load_data(self, urls: list[str]) -> list[Document]:
        docs = []
        with httpx.Client(timeout=120) as http:
            for url in urls:
                res = http.post(
                    "https://api.hydrafetch.com/v1/web/scrape",
                    headers={"X-API-Key": os.environ["HYDRAFETCH_API_KEY"]},
                    json={"url": url, "onlyMainContent": True},
                )
                data = res.json()["data"]
                docs.append(Document(text=data["markdown"], metadata=data["metadata"]))
        return docs

Vercel AI SDK

A tool your model can call mid-conversation when it needs a page it has not seen.

tools.ts

import { tool } from 'ai';
import { z } from 'zod';

export const readPage = tool({
  description: 'Read a web page and return it as clean Markdown.',
  parameters: z.object({ url: z.string().url() }),
  execute: async ({ url }) => {
    const res = await fetch('https://api.hydrafetch.com/v1/web/scrape', {
      method: 'POST',
      headers: {
        'X-API-Key': process.env.HYDRAFETCH_API_KEY!,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ url, onlyMainContent: true }),
    });

    const { data } = await res.json();
    return data.markdown;
  },
});

[ FAQ ]

Before you wire it up.

The longer answers live in the docs.

Do I need an API key, or can I sign in?

Either. Clients that speak the MCP OAuth flow, such as Claude Code, Cursor and OpenCode, can point at the endpoint and sign in through the browser. Everything else sends an API key as a bearer token. The two are equivalent in what they can do.

What does a tool call cost?

The same as the matching HTTP endpoint. A page is one credit whatever it took to fetch, extract and brand are five, and a failed call costs nothing. Connecting over MCP never costs more than calling the API directly.

Can my whole team share one connection?

An API key belongs to the workspace, so a key in a shared config works for everyone and the usage lands on the same balance. Signing in with OAuth ties the connection to you inside that workspace.

My client is not listed. Will it work?

Almost certainly. The endpoint is a standard streamable HTTP MCP server, so any client that can take a URL and an Authorization header can use it. The listed configs are just the shapes each client expects.

[ Start ]

Point your agent at it in under a minute.

Six tools, one endpoint, and the same credit cost as calling the API directly.

Get API key Read the docs