Use Hive with OpenAI and ChatGPT

Use Hive from ChatGPT or the OpenAI API when your agent needs live crypto evidence instead of training-cutoff answers. Eligible ChatGPT workspaces can create an OAuth MCP app; server-side Responses API agents can pass a Hive API key as an explicit headless authorization token.

Current compatibility

Hive's public MCP endpoint is https://mcp.hiveintelligence.xyz/mcp. Interactive clients use OAuth discovery; headless callers can use Authorization: Bearer <YOUR_HIVE_API_KEY>.

OpenAI currently exposes two relevant MCP paths:

• ChatGPT developer-mode apps: eligible Business and Enterprise/Edu workspaces can create a custom app, provide Hive's endpoint, choose OAuth, scan tools, and complete browser authorization.
• Responses API remote MCP: server-side code can provide a remote MCP server_url and an API-key authorization token in the tools array.

OpenAI describes ChatGPT custom MCP apps as a beta, workspace-controlled surface. Availability and admin permissions can differ by plan.

Before you start

1. A ChatGPT Business or Enterprise/Edu workspace with developer mode enabled for the custom-app path.
2. A Hive API key from /dashboard/keys only for the headless Responses API path.
3. An OpenAI API key if you are using the Responses API.

Keep API keys on your server. Do not paste production keys into prompts or client-side code.

Recommended for ChatGPT: custom OAuth app

OpenAI's current developer-mode flow is workspace- and role-dependent:

1. Enable developer mode for your account through the workspace or user Apps settings.
2. Open Settings → Apps → Create.
3. Name the app Hive and provide https://mcp.hiveintelligence.xyz/mcp as the endpoint.
4. Choose OAuth authentication.
5. Select Scan Tools, complete Hive's browser consent screen, then wait for the scan to finish.
6. Create the draft app and enable it for a new chat.

Review the discovered actions before publishing to a workspace. Source: OpenAI developer mode and MCP apps.

ChatGPT requires durable OAuth connectivity for an app to stay connected. Hive's authorization-server metadata advertises offline_access, and the release-candidate flow issues rotating refresh tokens; the live install-readiness gate checks that metadata before the site advertises OAuth setup as ready.

Recommended: Responses API remote MCP

Use Hive as a remote MCP tool from server-side OpenAI API code:

import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const response = await openai.responses.create({
  model: "gpt-5",
  input: "Use Hive to get the current BTC and ETH prices in USD.",
  tools: [
    {
      type: "mcp",
      server_label: "hive",
      server_description: "Live crypto market, wallet, DeFi, and token-risk tools from Hive Intelligence.",
      server_url: "https://mcp.hiveintelligence.xyz/mcp",
      authorization: process.env.HIVE_API_KEY,
      allowed_tools: [
        "search_tools",
        "get_api_endpoint_schema",
        "invoke_api_endpoint",
        "validate_task_result",
      ],
    },
  ],
});

console.log(response.output_text);

That keeps OpenAI orchestration in your app while Hive handles live crypto data, tool discovery, upstream provider auth, and normalized execution metadata. The allowed_tools list imports Hive's root discovery loop instead of exposing every category-listing helper to the model.

OpenAI's remote MCP flow first imports tools from the server as an mcp_list_tools output item, then emits an mcp_call item when the model calls a tool. For Hive, the expected root flow is:

1. search_tools to find the right Hive task/tool.
2. get_api_endpoint_schema when the argument shape is unknown.
3. invoke_api_endpoint to execute the selected Hive provider tool.
4. validate_task_result to check the final workflow envelope before presenting it.

This default allowlist is intentionally read-only. Add invoke_stateful_endpoint only for a workflow that needs Hive monitors, memory, or alert-state changes, and keep OpenAI approval enabled for every such call.

For production workflows, keep OpenAI's default approval flow enabled until you have reviewed the tool names, arguments, and returned data. Only use require_approval: "never" or a narrower require_approval object after you have a logged allowlist for low-risk tool calls. See OpenAI's MCP and connectors guide for allowed_tools, mcp_list_tools, mcp_call, and approval behavior.

Verify it worked

Run the example with a valid OpenAI key and Hive key, then inspect the response output. A successful OpenAI-side run should include:

• an mcp_list_tools item for server_label: "hive" with the allowed Hive root tools
• an mcp_call item whose name is usually search_tools, get_api_endpoint_schema, invoke_api_endpoint, or validate_task_result
• current BTC/ETH data in the tool output, with Hive metadata such as provider, runtime status, and freshness when the invoked provider tool returns it

If the model answers without using Hive, inspect the Responses API event stream or output array and confirm the server_url, authorization, and allowed_tools fields are present.

Alternative: call Hive REST from your OpenAI agent

If you want explicit control over tool routing, expose Hive REST calls as your own function tools:

curl -X POST https://mcp.hiveintelligence.xyz/api/v1/execute \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_HIVE_API_KEY" \
  -d '{"tool":"get_price","args":{"ids":"bitcoin,ethereum","vs_currencies":"usd"}}'

Use this path when your agent framework already wraps HTTP tools or when you need custom rate limiting, validation, and logging before Hive calls.

ChatGPT app beta notes

OpenAI's ChatGPT app/developer-mode surface is changing quickly. As of this page's last update:

• Full ChatGPT MCP app support is beta and workspace/plan-dependent.
• OpenAI's developer-mode docs list SSE and Streamable HTTP as supported protocols.
• Hive uses OAuth discovery for interactive ChatGPT app authorization.
• Responses API code can continue using the authorization field with a server-side Hive key.

For a production workspace rollout, review scanned actions and access controls before publishing. For backend agents, use the Responses API MCP path above.

What to ask once connected

• "Use Hive to get BTC, ETH, and SOL prices in USD."
• "Check whether 0x6B175474E89094C44Da98b954EedeAC495271d0F has token-security risks."
• "Show the top DeFi protocols by TVL on Ethereum and note 24-hour changes."
• "Summarize this wallet's balances, NFT holdings, and risky token approvals."

Troubleshooting

The MCP connection fails. Check that the URL is exactly https://mcp.hiveintelligence.xyz/mcp and that your server passes the Hive API key as the MCP authorization token or as Authorization: Bearer YOUR_HIVE_API_KEY for REST calls.

ChatGPT asks for OAuth. Continue through Hive's browser consent screen. If it does not open, recreate the draft app and check Hive status.

Tools do not appear. In ChatGPT, run Scan Tools again after authorization. In Responses API code, confirm the caller can reach mcp.hiveintelligence.xyz and that the server-side key is valid.

The model cannot call the price tool directly. On Hive's root /mcp, provider tools are reached through invoke_api_endpoint after discovery/schema lookup. Either keep invoke_api_endpoint in allowed_tools, or connect to a category-scoped Hive endpoint when you intentionally want direct category tools.

You need a different MCP client. Use Claude Desktop, Claude Code, Grok, Cursor, Windsurf, VS Code, Codex CLI, or Gemini CLI.

Next steps

• Agent Resources: prompts, skills, and runtime resources
• REST API: direct backend integration
• Tools Reference: every callable Hive tool