Wire FoxAPIs into a ChatGPT custom GPT.

ChatGPT custom GPTs ingest an OpenAPI 3.0 schema to expose actions to the model. FoxAPIs publishes one at a stable cloud URL covering all 23 MCP tools. Paste two URLs, set Bearer auth with your FoxAPIs key, and ChatGPT picks the right tool from the user prompt automatically. No tunnels, no localhost relays, no servers.

Why an OpenAPI schema, not a tunnel?

ChatGPT's Action runtime makes outbound HTTPS calls from OpenAI's infrastructure to a public URL you specify. It cannot reach localhost, 127.0.0.1, or anything behind a NAT. Cloud-relay schemes (ngrok, Cloudflare Tunnel, Tailscale Funnel) work but add a hop, a token, and a maintenance burden.

FoxAPIs already publishes the MCP endpoint at https://www.mentionfox.com/mcp. The schema at /mcp/openapi.json is auto-generated from the same tool manifest that the MCP tools/list method returns, so it stays in sync as new tools land. ChatGPT, Claude.ai, Cursor, and every other agentic client that supports either MCP or OpenAPI Actions can read this single source of truth.

Step 1 — Create your custom GPT

Open chat.openai.com, click your profile in the top-right, then My GPTs → Create. ChatGPT's GPT Builder opens with a Create tab (conversational setup) and a Configure tab (the manual form). Skip the Create tab and click Configure.

Give the GPT a name (e.g. "FoxAPIs Research Analyst"), a description, and an instruction block (template provided below). You don't need a logo to get started; one is generated automatically.

Step 1 — the Configure tab in the ChatGPT GPT Builder.

Step 2 — Enable Actions with Bearer authentication

Scroll to the bottom of the Configure form. Under Actions, click Create new action. The Action editor opens with three sections: Authentication, Schema, and Privacy policy.

Click Authentication. Select API Key. In the Auth Type sub-row, choose Bearer. Paste your FoxAPIs bearer token in the API Key field. The token is the same one you'd use against https://www.mentionfox.com/mcp in any other MCP client — grab it from mentionfox.com/connect if you don't have one yet.

Save the auth panel. ChatGPT will now send Authorization: Bearer <your-token> on every action call.

Step 2 — API Key + Bearer auth, FoxAPIs bearer token pasted in.

Step 3 — Set the cloud MCP endpoint

Back on the Action editor, the Schema section accepts either pasted JSON/YAML or a URL to import from. The server URL inside the schema points to the cloud MCP endpoint. You don't need to set this manually — the OpenAPI document declares it under the servers array.

If you ever need to override the host (e.g. running against a staging environment), edit the servers[0].url field after import. For production, leave it as https://www.mentionfox.com/mcp.

Step 3 — cloud MCP endpoint declared in the OpenAPI servers array.

Step 4 — Import the OpenAPI schema

In the Schema section click Import from URL. Paste:

https://www.mentionfox.com/mcp/openapi.json

ChatGPT fetches the schema, parses 23 operations (one per tool), and renders them in the Available Actions panel. Each action shows its operationId (the tool name), the HTTP method (POST), and the input parameters. Save the GPT.

The 23 actions: get_investor_report, get_entrepreneur_report, enrich_person, find_journalists_covering, scan_for_mentions, save_to_my_pipeline, get_my_recent_research, clarify_research_intent, get_dossier, compare_people, export_report, subscribe_to_pipeline_watch, get_pipeline_watch_digest, deep_dive_pipeline_company, custom_pipeline_watch, get_geofixer_score, get_geofixer_top_actions, run_geofixer_audit, vet_person, compare_subjects, find_contact, evaluate_influencer, score_intent.

Step 4 — 23 actions imported and ready in the GPT Builder.

Recommended GPT instructions

Paste this into the Instructions box on the Configure tab. The keyword cues help ChatGPT pick the right action without burning a clarification round-trip.

// Instructions box
You are an OSINT-grade research analyst with access to FoxAPIs tools.
Pick a tool by intent:
- "vet", "background", "screen", "look up"  → vet_person
- "find email", "contact info", "get phone" → find_contact
- "compare X vs Y" or "rank these"          → compare_subjects
- "find mentions", "track", "scan for"      → scan_for_mentions
- "buying intent", "filter mentions"        → score_intent
- "build a brief", "deep intel", "dossier"  → get_dossier
- "founder DD", "vetting report"            → get_entrepreneur_report
- "investor snapshot", "vet investor"       → get_investor_report
- "find journalists covering X"             → find_journalists_covering
- "evaluate influencer", "creator vetting"  → evaluate_influencer
- "save to pipeline", "park this"           → save_to_my_pipeline

When two profiles match a name, present the candidate list to the user
and ask which they meant. Always cite source URLs from the response.

Three worked examples

Example 1 — Sales-ops GPT

Configure the GPT for sales-ops. The user prompts:

Find people on Twitter and Hacker News asking about CRM
alternatives this week, score by buying intent, and save the
top 5 to my pipeline.

The GPT chains scan_for_mentions → score_intent → save_to_my_pipeline automatically. ChatGPT presents intermediate results inline so the user can see what landed in the pipeline.

Example 2 — Founder-research GPT

Build me a dossier on the founder of Anthropic before
my 9am tomorrow. Deep depth, include network.

Single call to get_dossier with refresh=true on cache miss, free on cache hit. For investment-grade vetting use get_entrepreneur_report instead — the 12-section format is investor-deck ready.

Example 3 — GEO-monitoring GPT

What's my GEOFixer score for resend.com today, and what
are the top 5 actions ranked by impact?

The GPT chains get_geofixer_score with get_geofixer_top_actions, returns the score plus a ranked action plan with concrete URLs.

Common errors & fixes

How the schema stays in sync

The OpenAPI document at /mcp/openapi.json is built on every request from the same TOOLS_MANIFEST array that powers the MCP tools/list method. A new tool added to the FoxAPIs back-end shows up automatically the next time ChatGPT re-imports the schema — no manual sync, no out-of-date Action lists, no schema drift between MCP-native and OpenAPI-Action clients. Hit Re-import on the Action editor whenever a new release ships and ChatGPT picks up the additions.

This matters because both ChatGPT and Claude.ai cache the resolved Action list inside the GPT or connector. If we shipped a stale schema, agents would either hallucinate tool names that no longer exist, or miss tools that just landed. Building the spec at request time from the live manifest is the simplest way to make that class of bug impossible.

Privacy & data handling

ChatGPT sends action calls from OpenAI's infrastructure to www.mentionfox.com. The bearer token authenticates the request to your FoxAPIs account; OpenAI never sees your data after it lands at FoxAPIs. Tool results return inline and are presented to the user in the chat — ChatGPT may use the response content to inform its next response, but the underlying database is yours. No persistence happens at OpenAI beyond the conversation transcript.

What's next

The same OpenAPI schema works for any agentic client that ingests OpenAPI Actions: ChatGPT, Mistral's Le Chat, Perplexity Spaces (when available), and the OpenAI Assistants API. For MCP-native clients (Claude.ai, Claude Desktop, Cursor, Continue, Goose, LibreChat) point them at https://www.mentionfox.com/mcp directly — the OpenAPI URL is unnecessary in MCP mode because the client speaks JSON-RPC and reads the manifest via tools/list instead.

The FoxAPIs Desktop App ships with a one-click connector hub that wires Claude Desktop, Cursor, Continue, and Goose automatically — and includes the same ChatGPT walkthrough above for cloud-only setups. Run it locally if you want every supported client configured from one place; stick with this walkthrough if ChatGPT is the only client you need.