How do I connect a remote MCP to ChatGPT?

Best move: add mcp.bassethound.ai/mcp as a custom connector in ChatGPT’s Developer mode, or pass it as an mcp tool in the Responses API.

Why it works: a remote MCP is a hosted endpoint, not a plugin you install. ChatGPT speaks MCP over HTTP, so pointing it at a URL is the whole handshake, and every tool the server exposes becomes callable.

Key takeaways

• ChatGPT connects to remote MCP servers two ways: custom connectors in the app (Developer mode) and the mcp tool type in the Responses API.
• A remote MCP is a URL, not an install. You connect the endpoint once and every tool it exposes becomes callable.
• Bassethound’s endpoint is mcp.bassethound.ai/mcp. Add it as an OAuth connector and sign in when prompted.
• Custom connectors in the ChatGPT app require a paid plan; the Responses API path works from any OpenAI API account.
• Bassethound exposes one tool, sniff_domain(domain, profile), returning the full five-layer dossier in a single call.

What are the two ways to connect a remote MCP to ChatGPT?

Two paths, depending on who you are. If you use the ChatGPT app, add the server as a custom connector. Turn on Developer mode, paste the server URL, and the tools appear inside your chats. This is the no-code path for end users on a paid plan. If you build agents, use the OpenAI Responses API instead. You pass the server as a tool of type mcp, and the model calls its tools inside a single API response.

Same protocol underneath, two front doors. The app path is fastest to try. The API path is what you ship. Both point at the same endpoint, mcp.bassethound.ai/mcp, and both surface the same tool, sniff_domain. Pick the app when you want to sniff a domain by hand mid-conversation. Pick the API when a program should do it on every inbound lead. Neither path installs software. A remote MCP is an endpoint someone else runs, so connecting is a handshake, not a download.

How do you add Bassethound as a connector in the ChatGPT app?

Open ChatGPT and go to Settings. Find Connectors. Turn on Developer mode under the advanced options (custom connectors are gated to paid plans). Create a new connector. Give it a name like Bassethound. Paste the MCP server URL, https://mcp.bassethound.ai/mcp. Choose OAuth for authentication and sign in when ChatGPT prompts you. Save.

ChatGPT validates the endpoint and lists the tools it exposes, which for Bassethound is one: sniff_domain. Now start a chat and ask something like “sniff stripe.com and tell me the AI stack.” ChatGPT recognizes the tool, calls sniff_domain with the domain and a profile, and folds the five-layer dossier into its answer. The first call may show an approval prompt so you can see what the tool is about to do. Approve it, or set the connector to run without prompting once you trust it. If the domain needs more depth, ask for the deep profile and ChatGPT passes profile: deep. The connection itself carries no state between calls.

How do you call a remote MCP from the Responses API?

Pass Bassethound as a tool in the tools array. This is the harder of the two paths, because it needs an access token and the Responses API runs no sign-in flow of its own. You obtain the token yourself by registering an OAuth client against the endpoint and completing the flow; there is no self-serve token page today. If you want the short route, use the connector path above and let ChatGPT run the sign-in. Minimal shape:

{
  "model": "gpt-4.1",
  "input": "Sniff stripe.com. What model providers show up?",
  "tools": [
    {
      "type": "mcp",
      "server_label": "bassethound",
      "server_url": "https://mcp.bassethound.ai/mcp",
      "headers": { "Authorization": "Bearer YOUR_ACCESS_TOKEN" },
      "require_approval": "never"
    }
  ]
}

The model reads the tool list Bassethound advertises, calls sniff_domain, and reasons over the result in the same response. server_label names the connection. server_url is the endpoint. require_approval controls whether tool calls pause for a human; set it to never for automation, or keep approvals on while you test. Pass the access token you obtained in a headers block. To lock the surface, add allowed_tools with just sniff_domain, though Bassethound exposes only that one anyway. Want to gate depth? Have your prompt or system message specify the profile: fast for a quick pass, standard by default, deep when a lead is worth the extra probes. The API path is the one you wire into a pipeline: score every inbound domain, enrich every new signup, qualify a list overnight.

Do you need an API key or OAuth for Bassethound?

No key for the free tier. That is the point. Bassethound owns the crawl, so it does not ask you to bring your own key for some upstream service. In the ChatGPT app, add the connector with OAuth and sign in when prompted; in the Responses API, you supply a token you obtained yourself. The free tier limit is enough for interactive use and light automation.

When you outgrow that, a paid plan buys higher rate limits, more concurrency, and the deeper follow-on probes. Your sign-in is how the server knows which plan to meter you on. Contrast this with enrichment tools that require an API key up front, even to try one lookup. Every user has to provision a key, store it, and rotate it. A keyless remote MCP collapses that to a URL. For a team wiring Bassethound into ChatGPT across ten seats, that difference is ten key handoffs you never make.

What breaks when connecting a remote MCP to ChatGPT, and how do you fix it?

Common snags, in the order they bite. No Developer mode in Settings means you are on a free ChatGPT plan; custom connectors need a paid one, and the Responses API works from any API account instead. Point the connector at the streamable HTTP MCP URL, mcp.bassethound.ai/mcp. It is not a downloadable bundle or a stdio command, and ChatGPT connects to remote servers, never local ones. A connector that fails to validate was unreachable or mistyped, so re-check the exact path down to the /mcp. The model also has to decide to call the tool. Name the domain in your prompt (“sniff acme.com”) instead of hoping it infers one. Approval prompts stall automation; set require_approval to never once you trust the flow.

The last one is not a connection bug at all. A static crawl plus optional JS render can miss fully server-side or proxied components. Bassethound flags those gaps inside the dossier rather than guessing, so a thin AI-readiness result can mean the signals are backend-only, not that the connection failed.

Bassethound perspective

Every enrichment vendor will tell you an API key is table stakes. We disagree, and the disagreement is structural, not cosmetic. Clearbit, ZoomInfo, and the OSINT tools hand you a key because you are querying their private corpus, and the key is how they meter and gate it. Bassethound owns the crawl. We fetch the domain live on every call, so there is nothing to gate behind a key on the free tier. That is why connecting to ChatGPT is a URL and a sign-in, not a provisioning ticket. It also means one connector serves a whole team without ten key handoffs.

The second bet: an agent should get correlation in one call, not stitch it from five MCPs. Point ChatGPT at a tech-stack MCP, an infra MCP, and a firmographics MCP, and the model has to fuse three unaligned payloads itself, badly. sniff_domain returns tech, infrastructure, firmographics, AI-readiness, and security already correlated, keyed to one fetch of one domain. Fusion is the moat. A key wall is friction competitors sell as security.

Sources

• Model Context Protocol, transports (Streamable HTTP): https://modelcontextprotocol.io/docs/concepts/transports
• OpenAI Responses API, remote MCP servers: https://platform.openai.com/docs/guides/tools-remote-mcp
• OpenAI Platform, tools overview: https://platform.openai.com/docs/guides/tools