Documentation

Fringe speaks the Model Context Protocol (MCP) over HTTP. Connect any MCP client with your API key, or call the endpoint directly from your own agent.

Quickstart

Two things to know:

·Endpoint: https://platform.bearinglabs.ai/mcp
·Auth: a bearer token. Create one on the API keys page.

Every request is authenticated with your key and metered against your credit balance. Pass it as a header:

header

Authorization: Bearer fringe_sk_live_...

Claude Code

Add Fringe as an HTTP MCP server in one command:

shell

claude mcp add --transport http fringe https://platform.bearinglabs.ai/mcp \
  --header "Authorization: Bearer fringe_sk_live_..."

The Fringe tools are now available in your sessions. Verify with /mcp.

Codex

OpenAI Codex CLI reads ~/.codex/config.toml. Bridge the HTTP endpoint with mcp-remote:

~/.codex/config.toml

[mcp_servers.fringe]
command = "npx"
args = [
  "-y", "mcp-remote",
  "https://platform.bearinglabs.ai/mcp",
  "--header", "Authorization: Bearer fringe_sk_live_..."
]

Cursor

Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

.cursor/mcp.json

{
  "mcpServers": {
    "fringe": {
      "url": "https://platform.bearinglabs.ai/mcp",
      "headers": { "Authorization": "Bearer fringe_sk_live_..." }
    }
  }
}

Claude Desktop

Claude Desktop connects to local (stdio) servers, so bridge with mcp-remote in claude_desktop_config.json:

claude_desktop_config.json

{
  "mcpServers": {
    "fringe": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://platform.bearinglabs.ai/mcp",
        "--header", "Authorization: Bearer fringe_sk_live_..."
      ]
    }
  }
}

Bespoke agents

Any MCP-compatible client works. Clients that support remote servers take a URL plus an Authorization header. Clients that only support local (stdio) servers can wrap the endpoint with mcp-remote:

shell

npx -y mcp-remote https://platform.bearinglabs.ai/mcp \
  --header "Authorization: Bearer fringe_sk_live_..."

To build into your own agent in code, use an MCP SDK over Streamable HTTP (below).

Call the API directly

The endpoint is JSON-RPC 2.0 over MCP Streamable HTTP. The cleanest path is an MCP SDK, which handles the handshake and session for you.

Python

python

import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

HEADERS = {"Authorization": "Bearer fringe_sk_live_..."}

async def main():
    async with streamablehttp_client("https://platform.bearinglabs.ai/mcp", headers=HEADERS) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([t.name for t in tools.tools])

            result = await session.call_tool(
                "google_dork",
                {"query": "annual report", "site": "sec.gov", "filetype": "pdf"},
            )
            print(result.structuredContent)

asyncio.run(main())

TypeScript

typescript

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(new URL("https://platform.bearinglabs.ai/mcp"), {
  requestInit: { headers: { Authorization: "Bearer fringe_sk_live_..." } },
});

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const { tools } = await client.listTools();
const res = await client.callTool({
  name: "wayback_lookup",
  arguments: { url: "https://www.python.org" },
});
console.log(res.structuredContent);

Raw HTTP

Speak JSON-RPC directly. Include Accept: application/json, text/event-stream, capture the Mcp-Session-Id header from initialize, and send it on subsequent calls.

shell

# 1) initialize — read the Mcp-Session-Id response header
curl -i https://platform.bearinglabs.ai/mcp \
  -H "Authorization: Bearer fringe_sk_live_..." \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{
        "protocolVersion":"2025-06-18","capabilities":{},
        "clientInfo":{"name":"curl","version":"1.0"}}}'

# 2) call a tool (reuse the session id from step 1)
curl https://platform.bearinglabs.ai/mcp \
  -H "Authorization: Bearer fringe_sk_live_..." \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: <from step 1>" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
        "name":"wayback_lookup",
        "arguments":{"url":"https://www.python.org"}}}'

Tools reference

Every tool returns structured JSON. Optional arguments are marked with ?.

Tool	Arguments	Description
tor_fetch	url, timeout?	Fetch an .onion or clearnet page over Tor.
tor_status	—	Check that the Tor network is reachable.
wayback_lookup	url, timestamp?	Find the closest archived snapshot of a URL.
wayback_search	url, match_type?, from_date?, to_date?, limit?	Enumerate archived captures of a URL or prefix.
wayback_fetch	url, timestamp	Retrieve the archived content of a specific capture.
google_dork	query, site?, filetype?, intitle?, inurl?, max_results?	Run an advanced search and get structured results.
craft_dork	objective, run?, count?, site?, max_results?	Describe what you want; an LLM crafts and runs the dork.
manual_task_types	—	List the human-in-the-loop task types you can request.
manual_task_submit	task_type, query, data?	Submit a task for a human to fulfil. Returns an ETA + poll interval.
manual_task_status	task_id	Check status and retrieve the result when ready.
manual_task_list	—	List the tasks you've submitted.