Connecting Agents

The Applicant Tracking MCP server lets an AI agent work your account through a small set of
task-shaped tools (browsing and creating jobs, moving applicants through your pipeline, and
so on). It is a remote MCP server that speaks the standard Streamable HTTP transport, so
any MCP-capable client can connect to it over HTTPS.

The one thing worth reading carefully is how you authenticate - it takes your existing
Applicant Tracking API credentials. Everything else is a normal remote-MCP setup.

Have your agent set it up

If you are using an agent that can edit its own MCP config or run shell commands (Claude Code,
Cursor's agent, VS Code Copilot agent mode, and similar), paste the prompt below as-is. It will
ask you for your API key and secret, so there is nothing to edit first.

Set up the Applicant Tracking MCP server for me.

First, ask me for my Applicant Tracking API key and API secret, and wait for my reply.
(Do not proceed until I have given you both.)

It is a remote MCP server that uses the Streamable HTTP transport:
- URL: https://mcp.applicant-tracking.com/mcp
- Auth: send the HTTP header  Authorization: Bearer <api_key>:<api_secret>
  (a single Bearer token: my API key, one colon, then my API secret - no spaces)

Once you have my credentials, add it to your own MCP configuration using whatever method is
correct for you. For example, in Claude Code that is:
  claude mcp add --transport http applicant-tracking https://mcp.applicant-tracking.com/mcp --header "Authorization: Bearer <api_key>:<api_secret>"
In Cursor or VS Code, add an entry to the mcp.json with the url and an Authorization header.

Then confirm the connection works by listing the available tools.

The rest of this page covers the endpoint, the credential format, and manual per-client setup
if you would rather do it yourself.

The endpoint

Authentication: your credential is a key:secret pair

The MCP server reuses your existing Applicant Tracking v1 API credentials, which come as a
pair: an API key and an API secret.

MCP clients send credentials as a Bearer token, so you combine the two halves into one
token, joined by a single colon:

Authorization: Bearer <api_key>:<api_secret>

For example, if your API key is ABC123 and your API secret is s3cr3t-value, the header
value is:

Authorization: Bearer ABC123:s3cr3t-value

In short: the "token" your MCP client asks for is literally the string
<api_key>:<api_secret> - your key, a colon, then your secret. The server splits it back
into the two halves and authenticates each request to the Applicant Tracking API on your behalf. The
credential is never stored; a wrong key or secret simply comes back as an authentication
error.

Where to get your API key and secret

Generate an API key/secret pair from your Applicant Tracking account's API settings (the same
credentials used for the v1 REST API). If you already integrate with the Applicant Tracking API, you
can reuse those credentials directly. Your access through the agent is exactly the access
those credentials already grant - the MCP server adds no permissions of its own.

Setup by client

The pattern is identical everywhere: give the client the server URL, then give it the bearer
token <api_key>:<api_secret>. Below are the specifics for the most common agents.

Claude Code (CLI)

Add the server with the claude mcp add command, passing the Authorization header with
--header:

claude mcp add --transport http applicant-tracking https://mcp.applicant-tracking.com/mcp \
  --header "Authorization: Bearer <api_key>:<api_secret>"

Then run claude and confirm with /mcp that applicant-tracking is connected. To scope the
server to your user (available in every project) add --scope user.

Cursor

Cursor reads MCP servers from ~/.cursor/mcp.json (global) or .cursor/mcp.json (per
project). Add:

{
  "mcpServers": {
    "applicant-tracking": {
      "url": "https://mcp.applicant-tracking.com/mcp",
      "headers": {
        "Authorization": "Bearer <api_key>:<api_secret>"
      }
    }
  }
}

Reload Cursor (or toggle the server in Settings -> MCP) and the tools appear.

VS Code (GitHub Copilot / Agent mode)

Add the server to your .vscode/mcp.json (workspace) or user mcp.json:

{
  "servers": {
    "applicant-tracking": {
      "type": "http",
      "url": "https://mcp.applicant-tracking.com/mcp",
      "headers": {
        "Authorization": "Bearer <api_key>:<api_secret>"
      }
    }
  }
}

Open the MCP view, start the applicant-tracking server, and its tools become available to agent
mode.

Any other MCP client

If your client supports remote/HTTP MCP servers with custom headers, you have everything
you need:

• URL: https://mcp.applicant-tracking.com/mcp
• Transport: Streamable HTTP
• Header: Authorization: Bearer <api_key>:<api_secret>

If your client's config exposes a generic list of headers, add Authorization with the value
above. If it only exposes a single "token" or "API key" field for bearer auth, put the
combined <api_key>:<api_secret> value there.

Verifying your connection

You can confirm the server is reachable and your credential works with curl.

List the available tools (no credential required - this just checks reachability):

curl -s https://mcp.applicant-tracking.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

Make an authenticated call (your credential is required and forwarded to the Applicant
Tracking API):

curl -s https://mcp.applicant-tracking.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer <api_key>:<api_secret>' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"list_jobs","arguments":{"per_page":5}}}'

A successful call returns a JSON-RPC result. If the credential is wrong or missing, you get a
clean authentication error rather than data.

Troubleshooting