Skip to content
Navo24Navo24

Core concepts

Connect Navo24 to any AI assistant

Add the Navo24 container-tracking MCP server to Claude, ChatGPT, Codex, Gemini, Grok, Hermes Agent, OpenClaw, Kimi, Qwen, DeepSeek or any other MCP client, with an API key or your TrackingMCP sign-in.

Some assistants list Navo24 in their own connector directory. The rest let you add a remote MCP server by hand. This page covers the second group: one server address, two ways to sign in, and the exact steps for Claude, ChatGPT and Codex, Gemini, Grok, Hermes Agent, OpenClaw, Kimi, Qwen, DeepSeek and the rest.

What you connect

Setting Value
Server https://mcp.trackingmcp.com/mcp
Transport Streamable HTTP
Sign-in API key (Authorization: Bearer tmcp_…) or your TrackingMCP account (OAuth)

The server is TrackingMCP, the same one behind the TrackingMCP connector in Claude. It offers seven tools:

Tool What it does
get_shipment_summary Your portfolio at a glance: active, exceptions, arriving soon, demurrage risk
get_container_detail Status, route, events, vessel and ETA for one container. A number your account does not track yet is added to tracking and counts toward your plan
get_vessel_position Last known AIS position of a vessel, with the age of the fix
get_demurrage_report Containers near or past their free days, with projected cost
get_port_congestion Wait times and congestion level at one or more ports
add_container Start tracking a container or bill of lading
get_demurrage_free_time Free days a carrier gives at a port before charges start

Two ways to sign in

API key. Works in every client on this page. Sign up at trackingmcp.com, open the developer settings and mint a key. It starts with tmcp_. The client sends it as Authorization: Bearer tmcp_YOUR_API_KEY. Where a client can read the key from an environment variable, the examples below do that. Where it cannot, the key sits in that client’s config file, so keep the file private.

TrackingMCP account (OAuth). The client opens a browser, you sign in to TrackingMCP and approve access, and no key is stored by hand. Clients that support OAuth find the sign-in server on their own from the server’s response. If a client cannot complete the sign-in, use the API key instead.

Every section below follows the same pattern: where to add the server, how to sign in, and one question to check it works. The check question is the same everywhere:

Use TrackingMCP to summarise my tracked shipments.

The assistant should call get_shipment_summary and answer with your container counts. A new account with no containers yet answers with zeros, which still proves the connection.

Claude

Anthropic connects Claude to remote MCP servers in two places: custom connectors in the Claude apps, and Claude Code in the terminal.

Claude, Claude Desktop and Cowork

Where to add it. Open Customize → Connectors, click + Add, then Add custom connector. Enter a name, paste https://mcp.trackingmcp.com/mcp and click Continue. On Team and Enterprise plans an Owner adds the connector first, then members click Connect.

Sign in with your TrackingMCP account. Under Authentication choose Sign in now and approve access in the window that opens.

Sign in with an API key. Choose No sign in, then under Request headers add Authorization with the value Bearer tmcp_YOUR_API_KEY. On a Team plan everyone who uses the connector shares that key.

Check it works. In a chat click +, then Connectors, switch TrackingMCP on and ask the check question. Claude reaches the server from Anthropic’s cloud, so the connector works the same on the web, desktop and mobile.

Claude Code

Sign in with an API key.

claude mcp add --transport http trackingmcp https://mcp.trackingmcp.com/mcp \
  --header "Authorization: Bearer tmcp_YOUR_API_KEY"

Add --scope user to use the server in every project.

Sign in with your TrackingMCP account. Add the server without --header, start claude, run /mcp, choose trackingmcp and sign in in the browser.

Check it works. /mcp lists trackingmcp as connected. Then ask the check question.

Source: Claude custom connectors and Claude Code MCP docs.

ChatGPT and Codex

OpenAI connects to MCP servers in ChatGPT as a custom plugin, and in Codex through one shared config file.

ChatGPT

Where to add it. Open chatgpt.com/plugins, click +, then Add custom MCP server. Enter a name and description, and under Connection paste https://mcp.trackingmcp.com/mcp. Account and workspace policies decide who may add custom servers.

Sign in. Choose your TrackingMCP account under authentication, confirm the risk warning with I understand and want to continue, then click Create as a plugin and approve access.

Check it works. In a new chat type @, choose the plugin, then ask the check question.

Codex

The Codex CLI, the IDE extension and the ChatGPT desktop app read the same ~/.codex/config.toml, so one entry covers all three.

Sign in with an API key. Add this to ~/.codex/config.toml. Codex reads the key from the environment variable you name:

[mcp_servers.trackingmcp]
url = "https://mcp.trackingmcp.com/mcp"
bearer_token_env_var = "TRACKINGMCP_API_KEY"
export TRACKINGMCP_API_KEY=tmcp_YOUR_API_KEY

Sign in with your TrackingMCP account. Keep only url in the entry, then run codex mcp login trackingmcp and approve access in the browser.

Check it works. codex mcp list shows the server. In the codex TUI, /mcp lists its tools. Then ask the check question.

Source: ChatGPT custom MCP servers and Codex MCP docs.

Gemini

Google offers MCP in two places: custom apps in the Gemini app, and the Gemini CLI for the terminal.

Gemini app

Where to add it. On a computer open gemini.google.com, click Settings, then Connected Apps. Under Custom apps click Add a custom app and paste https://mcp.trackingmcp.com/mcp. Once connected, the app works in the Gemini web app and the mobile app.

Sign in. The Gemini app only signs in with your TrackingMCP account: click Next and approve access in the window that opens. It cannot send an API key. Google currently limits custom apps to personal Google accounts in the US, aged 18 or over, with Keep Activity on, and the chat must be in English.

Check it works. Type @, choose the TrackingMCP app, then ask the check question.

Gemini CLI

Where to add it. Run gemini mcp add in a terminal. It writes the server to ~/.gemini/settings.json. Add --scope project to keep it in the current project’s .gemini/settings.json.

Sign in with an API key.

gemini mcp add --transport http --header "Authorization: Bearer tmcp_YOUR_API_KEY" \
  trackingmcp https://mcp.trackingmcp.com/mcp

The same entry written by hand in settings.json. httpUrl means Streamable HTTP; url would mean the older SSE transport:

{
  "mcpServers": {
    "trackingmcp": {
      "httpUrl": "https://mcp.trackingmcp.com/mcp",
      "headers": { "Authorization": "Bearer tmcp_YOUR_API_KEY" }
    }
  }
}

Sign in with your TrackingMCP account. Add the server without --header, start gemini and run /mcp auth trackingmcp. The CLI opens a browser and keeps the token in ~/.gemini/mcp-oauth-tokens.json.

Check it works. /mcp lists trackingmcp with its tools. Then ask the check question.

Source: Gemini Apps Help, custom apps and Gemini CLI MCP servers.

Grok

xAI connects Grok to MCP servers in three places: the grok.com chat, Grok Build in the terminal, and the xAI API.

grok.com

Where to add it. Open grok.com/connectors, click New Connector, choose Custom and enter https://mcp.trackingmcp.com/mcp. On Grok Business and Enterprise a team admin adds the connector first in the console, then members can switch it on.

Sign in. Complete the TrackingMCP sign-in when Grok asks for it. Grok then finds the tools on its own.

Check it works. Ask the check question in a new chat.

Grok Build

Sign in with an API key.

grok mcp add --transport http trackingmcp https://mcp.trackingmcp.com/mcp \
  --header "Authorization: Bearer tmcp_YOUR_API_KEY"

Or in ~/.grok/config.toml, with the key read from your environment:

[mcp_servers.trackingmcp]
url = "https://mcp.trackingmcp.com/mcp"
headers = { "Authorization" = "Bearer ${TRACKINGMCP_API_KEY}" }

Sign in with your TrackingMCP account. Add the server without --header. Grok opens the browser sign-in on first use; in the TUI, /mcps then i signs in again.

Check it works. grok mcp doctor trackingmcp tests the connection. Then ask the check question.

xAI API

In the Responses API, add the server as a tool. authorization goes out as the Authorization header to our server:

curl https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.7",
    "input": "Use TrackingMCP to summarise my tracked shipments.",
    "tools": [{
      "type": "mcp",
      "server_url": "https://mcp.trackingmcp.com/mcp",
      "server_label": "trackingmcp",
      "authorization": "Bearer tmcp_YOUR_API_KEY"
    }]
  }'

Source: Grok connectors, Grok Build MCP servers and xAI remote MCP tools.

Hermes Agent

Hermes Agent is Nous Research’s open-source agent. It runs in the terminal and on messengers such as Telegram, and it connects to MCP servers on its own.

Where to add it. mcp_servers in ~/.hermes/config.yaml, or the hermes mcp add command.

Sign in with an API key. Put TRACKINGMCP_API_KEY=tmcp_YOUR_API_KEY in ~/.hermes/.env, then add:

mcp_servers:
  trackingmcp:
    url: "https://mcp.trackingmcp.com/mcp"
    headers:
      Authorization: "Bearer ${TRACKINGMCP_API_KEY}"

Hermes fills ${TRACKINGMCP_API_KEY} from the environment when it connects, so the key stays out of config.yaml.

Sign in with your TrackingMCP account.

hermes mcp add trackingmcp --url https://mcp.trackingmcp.com/mcp --auth oauth
hermes mcp login trackingmcp

Check it works. hermes mcp test trackingmcp lists the tools. In a running chat, /reload-mcp picks up the new server. Then ask the check question.

Source: Hermes Agent MCP docs.

OpenClaw

OpenClaw is an open-source personal agent with a gateway for chat apps. It connects to MCP servers for every agent it runs.

Where to add it. In the Control UI open Settings → MCP → Add server, pick Streamable HTTP and enter the address. Or use openclaw mcp add, or edit mcp.servers in ~/.openclaw/openclaw.json.

Sign in with an API key. Keep the key in an environment variable and reference it:

{
  "mcp": {
    "servers": {
      "trackingmcp": {
        "url": "https://mcp.trackingmcp.com/mcp",
        "transport": "streamable-http",
        "headers": { "Authorization": "Bearer ${TRACKINGMCP_API_KEY}" }
      }
    }
  }
}

Sign in with your TrackingMCP account. Add the server with "auth": "oauth" and no headers. Stop the gateway, run openclaw mcp login trackingmcp, approve access in the browser, then start the gateway again.

Check it works. openclaw mcp doctor trackingmcp --probe connects and lists the tools. Then ask the check question.

Source: OpenClaw MCP servers and MCP transports.

Kimi Code

Kimi Code is Moonshot AI’s coding agent. It comes as a terminal app (CLI), a desktop app and a VS Code extension. The kimi.com chat does not document custom MCP servers, so connect through Kimi Code.

Where to add it. The CLI and the desktop app share one file, ~/.kimi-code/mcp.json. You can edit it directly, or run /mcp-config inside the CLI to add the server interactively. In the VS Code extension, open the gear menu and choose MCP Servers.

Sign in with an API key. Add this entry to ~/.kimi-code/mcp.json:

{
  "mcpServers": {
    "trackingmcp": {
      "url": "https://mcp.trackingmcp.com/mcp",
      "bearerTokenEnvVar": "TRACKINGMCP_API_KEY"
    }
  }
}

Then set the key in the terminal you start the CLI from:

export TRACKINGMCP_API_KEY=tmcp_YOUR_API_KEY

A desktop app opened from the Dock or Start menu does not see that variable, so in the desktop app and in VS Code sign in with your TrackingMCP account instead.

Sign in with your TrackingMCP account. Leave out bearerTokenEnvVar and run /mcp-config login trackingmcp in the CLI. In the VS Code extension, add an http server with the address above and press Authorize.

Check it works. Start a new session (open sessions do not pick up new servers), run /mcp to see the connection status, then ask the check question.

Source: Kimi Code docs for the CLI, the desktop app and VS Code.

Qwen Code

Qwen Code is the Qwen team’s terminal coding agent. This page covers Qwen Code.

Where to add it. Run qwen mcp add in a terminal. It writes the server to ~/.qwen/settings.json. Add --scope project to keep it in the current project’s .qwen/settings.json instead.

Sign in with an API key.

qwen mcp add --transport http trackingmcp https://mcp.trackingmcp.com/mcp \
  --header "Authorization: Bearer tmcp_YOUR_API_KEY"

The same entry written by hand in settings.json:

{
  "mcpServers": {
    "trackingmcp": {
      "httpUrl": "https://mcp.trackingmcp.com/mcp",
      "headers": { "Authorization": "Bearer tmcp_YOUR_API_KEY" }
    }
  }
}

Sign in with your TrackingMCP account. Add the server without --header. On the first connection Qwen Code opens a browser for the TrackingMCP sign-in. It listens for the answer on http://localhost:7777/oauth/callback, so run it on a machine with a browser. Use the /mcp dialog to see or reset the sign-in.

Check it works. Start qwen, run /mcp to confirm trackingmcp is connected, then ask the check question.

Source: Qwen Code MCP docs and the MCP server reference.

DeepSeek

The DeepSeek chat app does not offer MCP connectors. DeepSeek documents its models inside agent apps instead, and those apps do support MCP. Pick one of the two below, choose a DeepSeek model in it, and add the Navo24 server. The assistant then runs on DeepSeek and calls our tools.

OpenCode

OpenCode is an open-source coding agent for the terminal. DeepSeek lists it in its agent integrations.

Choose the DeepSeek model. Run opencode, type /connect, pick deepseek, paste your DeepSeek API key and select the DeepSeek-V4-Flash model.

Where to add it. opencode.json in your project, or ~/.config/opencode/opencode.json for every project.

Sign in with an API key. oauth: false stops OpenCode from starting a browser sign-in, and {env:…} reads the key from your environment:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "trackingmcp": {
      "type": "remote",
      "url": "https://mcp.trackingmcp.com/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:TRACKINGMCP_API_KEY}" }
    }
  }
}

Sign in with your TrackingMCP account. Keep only type and url, then run opencode mcp auth trackingmcp. OpenCode registers itself, opens the browser and stores the token.

Check it works. opencode mcp list shows the server and its sign-in status. Then ask the check question.

Source: OpenCode MCP servers.

Claude Code on a DeepSeek model

DeepSeek offers an Anthropic-compatible API and a setup guide for Claude Code. Claude Code connects to MCP servers itself, so our tools work while the model is DeepSeek.

Choose the DeepSeek model. Set these before you start claude. deepseek-flash is the API name of DeepSeek-V4-Flash, and DeepSeek’s guide lists further variables.

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=YOUR_DEEPSEEK_API_KEY
export ANTHROPIC_MODEL=deepseek-flash

Add the server. Same command and sign-in as in Claude Code above. The MCP setup does not change with the model.

Any other MCP client

Most MCP clients take a remote server as a URL plus optional headers. The usual shape:

{
  "mcpServers": {
    "trackingmcp": {
      "url": "https://mcp.trackingmcp.com/mcp",
      "headers": { "Authorization": "Bearer tmcp_YOUR_API_KEY" }
    }
  }
}

Field names differ between clients (url, httpUrl, serverUrl), so check your client’s docs for remote or Streamable HTTP servers. If your client supports OAuth, leave out headers and it will offer the TrackingMCP sign-in.

A client that only runs local stdio servers can reach us through mcp-remote:

{
  "mcpServers": {
    "trackingmcp": {
      "command": "npx",
      "args": ["mcp-remote", "https://mcp.trackingmcp.com/mcp",
               "--header", "Authorization: Bearer tmcp_YOUR_API_KEY"]
    }
  }
}

Then ask the check question.

More Navo24 tools

Every step above works the same for our other servers: swap the address and keep the key. mcp.navo24.com adds distance and transit time, places, CO2e, parcels, vessels, road and rail routes, demurrage free time and flight schedules on one address, with an API key. The MCP quickstart lists every server.