Connect ChatGPT and OpenAI

ChatGPT and the OpenAI API both speak Model Context Protocol — so the same /{api_prefix}/_mcp endpoint that works with Claude works here too. This guide covers two paths: connecting through the ChatGPT UI (Custom Connectors), and connecting through the OpenAI Responses API when you build your own agent.

The Responses API path is more flexible (any auth header), while the ChatGPT UI path is OAuth-first and works best with public Flux APIs today.

Prerequisites

Before you start:

1. A Flux API with at least one connected folder. See Expose Content via Flux API.
2. Your environment key (e.g., 7c9h4pwu) and API prefix (e.g., blog).
3. A Flux API key pair (access_key + secret_key) if is_auth_required: true. Public APIs work without keys. See Manage Roles and API Keys.
4. For the ChatGPT UI path: ChatGPT Plus, Team, Edu, or Enterprise (Custom Connectors aren't on the free tier).
5. For the API path: an OpenAI API key with access to the Responses API.

If you haven't verified the endpoint yet, run the curl initialize + tools/list check from Connect Claude → Verify the endpoint first. The wire protocol is the same — once it works for curl, it works for any MCP client.

Path A — OpenAI Responses API (recommended for developers)

If you're building your own assistant or agent on top of OpenAI's API, the Responses API accepts MCP servers as a tool source via tools: [{type: "mcp", ...}]. Custom headers are fully supported, so FoxNose's Authorization: Secure ... scheme works out of the box on both public and private APIs.

from openai import OpenAI

client = OpenAI()  # OPENAI_API_KEY in env

response = client.responses.create(
    model="gpt-5",
    input="Find the three most-read articles about retrieval-augmented generation.",
    tools=[
        {
            "type": "mcp",
            "server_label": "foxnose-blog",
            "server_url": "https://7c9h4pwu.fxns.io/blog/_mcp",
            # Drop `headers` entirely for public APIs (is_auth_required=false).
            "headers": {
                "Authorization": "Secure <access_key>:<signature>",
            },
            # Optional: pre-approve specific tools to skip per-call confirmation prompts.
            "require_approval": "never",
        }
    ],
)

print(response.output_text)

The model can now call the five FoxNose tools (discover, get_schema, list, get_one, search) inside that single Responses call. OpenAI handles the MCP session, the tool advertisement, and the round-trip back to the model.

Path B — ChatGPT Custom Connectors (UI)

ChatGPT (Plus / Team / Edu / Enterprise) exposes MCP servers as Connectors. The flow is entirely UI-driven — paste the server URL, optionally configure OAuth, and the model gets the tools across all your conversations.

Public Flux APIs

If is_auth_required: false, the connector setup is trivial:

1. In ChatGPT, open Settings → Connectors → Add custom connector.
2. Paste the MCP server URL: https://7c9h4pwu.fxns.io/blog/_mcp
3. Leave authentication off.
4. Save. The tools become available in new conversations.

That's it — the discover, get_schema, list, get_one, and search tools show up exactly as they would in Claude.

Private Flux APIs — current limitation

ChatGPT's Connectors UI expects OAuth 2 for authenticated servers. FoxNose's Flux API uses a signed header scheme (Authorization: Secure <access_key>:<signature>), not OAuth. Three workarounds, ranked by effort:

1. Use Path A instead (OpenAI Responses API). Same model family, full auth-header flexibility, works today.
2. Run an OAuth-to-Secure proxy between ChatGPT and FoxNose. The proxy advertises OAuth to ChatGPT, holds your Flux API credentials, and forwards requests with the right Authorization: Secure header. Any small reverse proxy (e.g., a Cloudflare Worker, an Nginx Lua snippet, or a one-file Node.js server) works.
3. Wait for native support. OAuth 2 on the Flux API surface is on the roadmap — when it ships, ChatGPT will connect directly without a proxy.

For most teams that already have an OpenAI subscription for their developers, Path A is the simplest answer.

Verifying it works

After connecting via either path, a quick smoke test:

• Responses API: the response's output array includes one or more mcp_call items showing which tools the model invoked and what they returned. Inspect these to confirm the right tools fired.
• ChatGPT UI: ask the model "what tools do you have from the foxnose-blog connector?" — it should enumerate the five FoxNose tools. Then ask a content-grounded question and verify it cites results from your folders.

If the tool list doesn't show up, the most common causes are: wrong URL prefix (double-check /{api_prefix}/_mcp), mcp_enabled: false on the API row, or auth mismatch (key not yet propagated, wrong signature). The MCP Server reference lists the exact error envelopes the endpoint returns.

Hiding the agent surface

Just like with Claude, you can hide the MCP endpoint for any specific Flux API prefix by flipping mcp_enabled: false through the Management API. The REST endpoints continue to work; only /_mcp returns 404. See the Connect Claude guide for the PATCH example.

What's next?

Explore the MCP server protocol details — session lifecycle, tool result envelope, error codes, and rate limits.

Build a deeper integration — wire FoxNose into a custom RAG pipeline using the SDK rather than tools.