Docs

MCPifex Quickstart: Connect an MCP Server in 5 Steps

Published · Updated · 5 min read

An MCPifex quickstart is five steps: create an instance of a catalog MCP server in the portal, choose which of its tools are enabled, run a test connection, generate an API key, and point an MCP client at the gateway URL. MCPifex then runs the real server process for you — you never install, host, or manage it yourself.

Before you start

Register a free account at https://portal.mcpifex.com/en/auth/register — no card required. You'll also need an MCP client that speaks Streamable HTTP (Claude Code, Claude Desktop, ChatGPT, Cursor, or a raw HTTP client is enough to test with), and whatever credentials the server you're connecting expects — a database host, user, and password for PostgreSQL, for example.

As of September 2026, MCPifex hosts PostgreSQL, Google Trends, and Google Search Console. PostgreSQL and Google Trends are listed on the public marketplace; Google Search Console is hosted too, but it isn't listed on the marketplace — that's an owner choice, not a hosting limit. MySQL and Filesystem are in the catalog but not yet launchable — creating an instance of either is possible, but there's no server to run behind it yet.

Step 1: create an instance

In the portal, pick a server from the catalog and create an instance of it. An instance is your own configured copy of that server — its credentials, its enabled tools, and its own API key all live under that one instance. You can create more than one instance of the same server, for example a separate PostgreSQL instance per database, up to your plan's instance limit.

Step 2: choose which tools are enabled

Every catalog server lists its tools in the instance's settings. Read-only tools are on by default; anything destructive — a SQL execute, a sitemap delete — starts off and has to be switched on deliberately. This isn't just a UI default: the gateway enforces it at call time. tools/list only ever returns the tools you enabled, and a tools/call for anything you didn't enable is refused, whether or not the underlying package supports it.

Step 3: run a test connection

Before you finish setting up an instance, click "Test connection." The portal calls a real health-check tool on the server over the same path a live client would use, so a wrong password or a missing scope shows up immediately instead of surfacing on your first real query.

Step 4: generate an API key

Once the test passes, generate an API key for the instance. Keys start with mcpx_. Revoking a key from the portal stops new calls within about a minute.

Step 5: connect your MCP client

Every client points at the same gateway endpoint, https://mcpifex.com/mcp — only how it presents the key differs.

Claude Code

Add the gateway as an HTTP MCP server with the key in a header:

#!/bin/sh
# MCPifex — Claude Code CLI snippet.
# Replace <YOUR_MCPX_KEY> with your MCPifex API key (starts "mcpx_"), from
# the portal's API key page, then run this once from any shell that has the
# `claude` CLI on PATH.
claude mcp add mcpifex --transport http https://mcpifex.com/mcp \
  --header "Authorization: Bearer <YOUR_MCPX_KEY>"

A client that can't send headers

ChatGPT's custom-connector form, and any other client with no way to add an Authorization header, uses the key as the first path segment of the URL instead. Replace <YOUR_MCPX_KEY> with your MCPifex API key (starts mcpx_), from the portal's API key page:

  1. On ChatGPT web, open Settings → Security and login → Developer mode and enable it if your account and workspace allow it.
  2. Open ChatGPT Plugins, use the plus button, and create a developer-mode app named MCPifex with a short description.
  3. Set the MCP server URL to https://mcpifex.com/mcp/<YOUR_MCPX_KEY>.
  4. Choose No Authentication (or None): the MCPifex key in the URL authenticates the gateway request.
  5. Create the connection and review the discovered tools.
  6. In a conversation, use the plus menu → Developer mode, select the app, and test one named read-only tool.

These steps follow the OpenAI developer-mode documentation, checked in September 2026. Availability depends on your plan and workspace policy.

Treat this URL like a password: anyone who has it can call every tool enabled on that key. Rotate the key from the portal if it ever leaks.

Verify the handshake with curl

Useful for debugging a client, or for confirming an instance works before wiring it into anything:

#!/bin/sh
# MCPifex — raw MCP handshake over curl (initialize + tools/list).
# Replace <YOUR_MCPX_KEY> with your MCPifex API key (starts "mcpx_"), from
# the portal's API key page. Requires curl only.
set -e

GATEWAY_URL="https://mcpifex.com/mcp"
MCPX_KEY="<YOUR_MCPX_KEY>"

# 1. initialize — the gateway replies with an Mcp-Session-Id response header
#    that every later request on this session must echo back.
INIT_HEADERS=$(mktemp)
INIT_BODY=$(mktemp)
curl -sS -D "$INIT_HEADERS" -o "$INIT_BODY" \
  -X POST "$GATEWAY_URL" \
  -H "Authorization: Bearer $MCPX_KEY" \
  -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": "mcpifex-curl-example", "version": "1.0.0" }
    }
  }'

SESSION_ID=$(grep -i '^mcp-session-id:' "$INIT_HEADERS" | tr -d '\r' | cut -d' ' -f2-)
echo "Mcp-Session-Id: $SESSION_ID"
cat "$INIT_BODY"
echo
rm -f "$INIT_HEADERS" "$INIT_BODY"

# 2. tools/list — filtered to the tools enabled for this API key.
curl -sS -X POST "$GATEWAY_URL" \
  -H "Authorization: Bearer $MCPX_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: $SESSION_ID" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/list",
    "params": {}
  }'
echo

Two ways to authenticate

Both forms accept the same key: an Authorization: Bearer mcpx_... header, or the key as the first path segment, https://mcpifex.com/mcp/mcpx_.... Use the header form wherever a client supports it; reach for the path form only when a client's connector UI has nowhere to put a header, since a URL is easier to end up copy-pasted somewhere it shouldn't be than a header is.

What happens after you connect

Your client's tools/list call returns exactly the tools you enabled in step 2 — nothing else on that server, and never a tool outside MCPifex's catalog for it. One isolated server process backs each client session, and it's stopped when the session closes or after it sits idle. Every call is logged per instance, and recent call logs and daily usage counts show up in the portal, so you can see what an agent actually did after the fact.

A free account covers 3 instances; if you outgrow that, plans go up to 30 without changing what a single call can do — instances are the only limit, tool calls themselves are unlimited on every plan.