Connect a client to the Queue CallBack MCP server

To connect an AI client to the Queue CallBack MCP server, point the client at https://mcp.queuecallback.com/mcp. Claude and ChatGPT connect by signing in with your Queue CallBack account, which gives read-only access. Every other client sends a Queue CallBack API key in the header Authorization: Bearer <key>, and so does any connection that makes changes. This page gives the sign-in steps for Claude and ChatGPT, copy-paste setup for each client that can send the header, the cases that cannot connect yet, and how to check a connection with the get_me tool.

For AI agents: this page is also available as Markdown at https://queuecallback.com/docs/mcp/connect.md. The whole MCP documentation in one file: https://queuecallback.com/docs/llms-full.txt

What every client needs

A Queue CallBack API key acts in exactly one organization: the one it was created in. A sign-in acts in the signed-in person's own organization. No tool takes an organization id, so the client cannot reach another organization.

Claude and ChatGPT open a Queue CallBack sign-in page when you connect them. That is expected. If any other client opens a browser or asks you to sign in when it connects to the Queue CallBack MCP server, the client did not send a working API key: the Authorization header is missing or empty, or the server refused the key. Queue CallBack supports sign-in from Claude and ChatGPT only, so cancel the sign-in and fix the header. If a sign-in completes anyway, get_me shows actor_type oauth, and the connection is read-only with caller numbers masked. See OAuth sign-in and The client opens a browser to sign in.

Set the API key environment variable

Signing in from Claude or ChatGPT needs no API key and no environment variable. Most other snippets on this page read the Queue CallBack API key from the environment variable QCB_API_KEY, so the key stays out of files you share or commit. Set the variable in the environment the client starts from.

# macOS and Linux: put this line in a shell profile only you can read, such as ~/.zshrc or ~/.bashrc
export QCB_API_KEY='qcb_sk_...'

# Windows PowerShell: prompts for the key, so it is not saved in your command history, and stores it for your user account. Open a new terminal afterwards.
[Environment]::SetEnvironmentVariable('QCB_API_KEY', [System.Net.NetworkCredential]::new('', (Read-Host -AsSecureString 'Queue CallBack API key')).Password, 'User')

To keep the key out of your shell profile, load it from the operating system's secret store instead, as shown in Store an API key safely.

• Desktop apps (Cursor, VS Code, Claude Desktop, Devin Desktop, JetBrains IDEs) read environment variables when they start. Quit and reopen the app after you set or change QCB_API_KEY.
• On macOS, an app started from the Dock or Finder may not see variables exported in ~/.zshrc. If the client fails with 401 or asks you to sign in after you set QCB_API_KEY, quit the app and start it from a terminal (for example open -a Cursor), or use the client's own prompt or secret store where it has one (VS Code inputs, Goose's secret store).
• Never store the key in a variable whose name starts with ANTHROPIC_. Claude Code reads its own credential variables as empty in a remote server's headers, so the server would receive no key.
• Some clients cannot read environment variables. Their sections say so, and the key goes into that client's settings file in plain text. Keep such a file private, never commit it, and update it when you rotate the key. See Rotate, revoke and suspension.

Client summary

"Can send the key today" means the client's own documentation shows a way to send a custom Authorization header, so it works with the Queue CallBack MCP server with an API key. Claude and ChatGPT can also sign in with a Queue CallBack account instead, read-only. Queue CallBack supports sign-in from those two clients only.

Sign in from Claude

Claude connects to the Queue CallBack MCP server as a custom connector that you sign in to with your Queue CallBack account. No API key is needed. A connector you add once works in claude.ai, Claude Desktop, the Claude mobile apps and Cowork. The connection is read-only: it acts as you, in your own organization, and it cannot change anything, place calls or unmask caller numbers (OAuth sign-in). To make changes from Claude, use an API key instead (Claude Desktop).

On a Free, Pro, Max or Ultra plan:

1. Open Customize > Connectors, choose + Add, then Add custom connector.
2. Enter the name Queue CallBack and the URL https://mcp.queuecallback.com/mcp, then choose Continue.
3. Review the settings Claude detected and choose Continue.
4. Under Authentication, choose Sign in now.
5. Under OAuth client, choose Use Claude's published identity (Recommended). Do not choose Register automatically or Use your own OAuth client: Queue CallBack offers no automatic registration and issues no client IDs, so those sign-ins fail.
6. Leave Request headers empty and choose Add.
7. Sign in with your Queue CallBack portal account and approve the access (What you see when you sign in).

If the dialog shows a single screen with Advanced settings instead, enter the name and URL, leave the OAuth client ID and client secret under Advanced settings empty, and choose Add.

On a Team or Enterprise plan:

1. The Owner opens Organization settings > Connectors, chooses Add, hovers over Custom and selects Web.
2. The Owner follows steps 2 to 6 above.
3. Each member opens Customize > Connectors, finds Queue CallBack (usually labeled Custom), chooses Connect, and signs in with their own Queue CallBack account. Each member then acts as themselves, with their own role and organization, so no key is shared.

To use the connector in a chat, choose + at the lower left, then Connectors, and turn on Queue CallBack. Then ask, for example: "Use the Queue CallBack get_me tool and tell me which organization and scopes I am connected with." Every tool a signed-in connection lists is read-only.

• Claude connects to the server from Anthropic's cloud, not from your computer.
• A connector cannot both sign in and send an Authorization header. To switch between sign-in and an API key, remove the connector and add it again.

A link that opens the Add custom connector dialog with the name and URL filled in:

https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Queue%20CallBack&connectorUrl=https%3A%2F%2Fmcp.queuecallback.com%2Fmcp

Team or Enterprise Owners use the organization form of the same link:

https://claude.ai/admin-settings/connectors?modal=add-custom-connector&connectorName=Queue%20CallBack&connectorUrl=https%3A%2F%2Fmcp.queuecallback.com%2Fmcp

To disconnect, open Customize > Connectors and choose Remove, or the three dots next to the connector (Disconnect or revoke sign-in).

Source: Get started with custom connectors, Add a connector that isn't in the directory and Connector authentication, checked 2026-11-05.

Sign in from ChatGPT

ChatGPT connects to the Queue CallBack MCP server as a custom MCP server that you sign in to with your Queue CallBack account. ChatGPT cannot send an API key, so a Queue CallBack connection in ChatGPT is always read-only: it acts as the person who signed in, in that person's own organization, and it cannot change anything, place calls or unmask caller numbers (OAuth sign-in). ChatGPT's sign-in also asks to see your name and email address (the standard openid, profile and email permissions); that gives it no further Queue CallBack access.

Custom MCP servers work in ChatGPT on the web, not in the mobile apps. Developer Mode is not needed.

1. Open Plugins at https://chatgpt.com/plugins, select the plus button, then select Add custom MCP server.
2. Enter the name Queue CallBack.
3. Under Connection, enter https://mcp.queuecallback.com/mcp.
4. For authentication, choose OAuth. Leave any client ID and client secret fields empty.
5. Review the risk warning, select I understand and want to continue, then select Create as a plugin.
6. When ChatGPT asks, sign in with your Queue CallBack portal account and approve the access (What you see when you sign in). Then review the tools ChatGPT found.
7. Install the plugin, start a new conversation, type @ in the prompt box and select the Queue CallBack plugin. Ask, for example: "Use get_me and tell me which organization and scopes I am connected with."

• On Business, Enterprise and Edu plans, only admins and owners can publish the plugin for the rest of the workspace. OpenAI's article below has the publish steps.
• After an admin publishes the plugin for a workspace, ChatGPT uses a snapshot of its tools. If Queue CallBack adds or changes tools, a workspace admin refreshes the tool list in the workspace's app settings.
• ChatGPT reaches the server from OpenAI's cloud, not from your computer.

For changes, calls or unmasked caller data with OpenAI tools, use the Codex CLI or the OpenAI Responses API with an API key.

Source: Connecting custom MCP servers in ChatGPT and ChatGPT plugin authentication, checked 2026-11-05.

Claude Code

Claude Code connects to the Queue CallBack MCP server over HTTP and sends the API key in the Authorization header. Set QCB_API_KEY first (Set the API key environment variable).

Option A: a project .mcp.json file

Create .mcp.json in the project root:

{
  "mcpServers": {
    "queuecallback": {
      "type": "http",
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer ${QCB_API_KEY}"
      }
    }
  }
}

• Claude Code replaces ${QCB_API_KEY} with the variable's value when it connects. The file holds no secret, so you can commit it and each person uses their own key.
• "type": "http" is required. Claude Code treats an entry that has a url and no type as a configuration error and skips it.
• Claude Code asks you to approve a project server the first time it loads it.
• GitHub Copilot harness sessions in VS Code read the same file format from a workspace-root .mcp.json (see VS Code).

Option B: claude mcp add

bash or zsh:

claude mcp add --transport http --scope user queuecallback https://mcp.queuecallback.com/mcp \
  --header 'Authorization: Bearer ${QCB_API_KEY}'

PowerShell:

claude mcp add --transport http --scope user queuecallback https://mcp.queuecallback.com/mcp --header 'Authorization: Bearer ${QCB_API_KEY}'

Keep the single quotes. They stop your shell from expanding the variable, so Claude Code stores the reference ${QCB_API_KEY} in ~/.claude.json and expands it each time it connects. claude mcp list and claude mcp get queuecallback show the reference by name, not the key.

Warning: the key in plain text. With double quotes, such as "Authorization: Bearer $QCB_API_KEY" in bash or "Authorization: Bearer $env:QCB_API_KEY" in PowerShell, your shell inserts the key itself, and Claude Code writes it in plain text to ~/.claude.json. If you did that, run claude mcp remove queuecallback --scope user and add the server again with single quotes. A stored key also has to be replaced by hand after every rotation.

--scope user makes the server available in all your projects. Without --scope, Claude Code adds the server for the current project only, still in ~/.claude.json.

Allow the read tools without prompts

Claude Code asks before it calls a tool from a new server. To stop the prompts for the Queue CallBack read tools, add these allow rules with /permissions, or in .claude/settings.json (this project) or ~/.claude/settings.json (all your projects):

{
  "permissions": {
    "allow": [
      "mcp__queuecallback__get_*",
      "mcp__queuecallback__list_*",
      "mcp__queuecallback__diff_flow",
      "mcp__queuecallback__validate_flow"
    ]
  }
}

• Every get_ and list_ tool of the Queue CallBack MCP server is read-only, and so are diff_flow and validate_flow.
• Do not allow mcp__queuecallback__*. That rule also allows the tools that change data.
• Tools that place real phone calls or change what callers hear, such as requeue_callback and publish_flow, are marked to ask on every call. Claude Code prompts for them even when an allow rule matches, and offers no "don't ask again" option. See Approval prompts.

Check Claude Code

claude mcp get queuecallback

In a session, /mcp lists the server and the tools your key can use. Then ask Claude to call get_me (Check the connection). With a configured Authorization header, a refused key shows as a failed connection, and Claude Code does not start a sign-in. Check that QCB_API_KEY is set in the shell that started Claude Code and that the key is active in the portal.

Source: Claude Code MCP docs and Claude Code permissions, checked 2026-11-05.

Cursor

Cursor reads the Queue CallBack API key from QCB_API_KEY through ${env:...} interpolation. Set the variable first (Set the API key environment variable), then restart Cursor.

Put this in ~/.cursor/mcp.json for all your projects (on Windows: %USERPROFILE%\.cursor\mcp.json, for example C:\Users\<you>\.cursor\mcp.json), or in .cursor/mcp.json in a project's root folder for that project only:

{
  "mcpServers": {
    "queuecallback": {
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:QCB_API_KEY}"
      }
    }
  }
}

Cursor resolves ${env:NAME} in the url and headers of a remote server. envFile works only for local (stdio) servers, so a remote server needs the environment variable.

• Cursor asks for approval before it uses an MCP tool by default. MCP tools follow the Run Mode set under Settings > Agents > Approvals & Execution. Do not use Run Everything with the queuecallback server: it runs every tool call without asking, and some Queue CallBack tools place real phone calls or change what callers hear.
• Allowlist only the read tools of the queuecallback server (get_*, list_*, diff_flow, validate_flow). For Cursor team admins: a tool allowlist under Team Settings > MCP Configuration that is left empty allows every tool of the server, so list the read tools.

Cursor install link

The install link carries the reference ${env:QCB_API_KEY}, never the key, so you can publish or share it. Cursor asks you to confirm before it installs the server.

cursor://anysphere.cursor-deeplink/mcp/install?name=queuecallback&config=eyJ1cmwiOiJodHRwczovL21jcC5xdWV1ZWNhbGxiYWNrLmNvbS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgJHtlbnY6UUNCX0FQSV9LRVl9In19

Web form of the same link, for a web page or a chat message. It opens a cursor.com page from which the link opens in Cursor:

https://cursor.com/link/mcp/install?name=queuecallback&config=eyJ1cmwiOiJodHRwczovL21jcC5xdWV1ZWNhbGxiYWNrLmNvbS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgJHtlbnY6UUNCX0FQSV9LRVl9In19

The config value is the Base64 encoding of {"url":"https://mcp.queuecallback.com/mcp","headers":{"Authorization":"Bearer ${env:QCB_API_KEY}"}}.

Source: Cursor MCP docs, Cursor run modes, Cursor MCP install links and Cursor deeplinks, checked 2026-11-05.

VS Code

VS Code (GitHub Copilot) can ask for the Queue CallBack API key once and keep it in its secret storage. Put this in .vscode/mcp.json in your workspace, or in your user profile's mcp.json (Command Palette: MCP: Open User Configuration):

{
  "inputs": [
    {
      "type": "promptString",
      "id": "qcb_api_key",
      "description": "Queue CallBack API key, starts with qcb_sk_",
      "password": true
    }
  ],
  "servers": {
    "queuecallback": {
      "type": "http",
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:qcb_api_key}"
      }
    }
  }
}

VS Code asks for the key when the server first starts and stores it for later sessions. To read QCB_API_KEY instead, drop inputs and use "Authorization": "Bearer ${env:QCB_API_KEY}".

• VS Code asks you to approve a tool call unless you granted a broader approval. Grant a lasting approval, such as Always Allow, only to the read tools of the queuecallback server (get_*, list_*, diff_flow, validate_flow), and do not tick the checkbox that trusts every tool of the server at once.
• Do not use the Allow all permission level, Autopilot or the setting chat.tools.global.autoApprove while the queuecallback server is on. They skip confirmation for every tool, and some Queue CallBack tools place real phone calls or change what callers hear. Chat: Reset Tool Confirmations in the Command Palette clears approvals you saved.

Copilot harness sessions

Copilot harness sessions do not receive servers that need an ${input:...} prompt. For those sessions, use the portable format: .mcp.json at the workspace root, or the Copilot CLI user file ~/.copilot/mcp-config.json. The portable format reads ${QCB_API_KEY} from the environment:

{
  "mcpServers": {
    "queuecallback": {
      "type": "http",
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer ${QCB_API_KEY}"
      }
    }
  }
}

VS Code install link

The install link holds the password prompt definition, never the key. VS Code opens the server's details page so you can review the configuration before you install it.

vscode:mcp/install?%7B%22name%22%3A%22queuecallback%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.queuecallback.com%2Fmcp%22%2C%22headers%22%3A%7B%22Authorization%22%3A%22Bearer%20%24%7Binput%3Aqcb_api_key%7D%22%7D%2C%22inputs%22%3A%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22qcb_api_key%22%2C%22description%22%3A%22Queue%20CallBack%20API%20key%2C%20starts%20with%20qcb_sk_%22%2C%22password%22%3Atrue%7D%5D%7D

Web form of the same link, for a web page or a badge:

https://vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522queuecallback%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fmcp.queuecallback.com%252Fmcp%2522%252C%2522headers%2522%253A%257B%2522Authorization%2522%253A%2522Bearer%2520%2524%257Binput%253Aqcb_api_key%257D%2522%257D%252C%2522inputs%2522%253A%255B%257B%2522type%2522%253A%2522promptString%2522%252C%2522id%2522%253A%2522qcb_api_key%2522%252C%2522description%2522%253A%2522Queue%2520CallBack%2520API%2520key%252C%2520starts%2520with%2520qcb_sk_%2522%252C%2522password%2522%253Atrue%257D%255D%257D

For VS Code Insiders, replace vscode: with vscode-insiders: in the install link, or vscode%3A with vscode-insiders%3A in the web form.

From the command line (bash or zsh). This adds the server to your user profile and reads the key from QCB_API_KEY:

code --add-mcp '{"name":"queuecallback","type":"http","url":"https://mcp.queuecallback.com/mcp","headers":{"Authorization":"Bearer ${env:QCB_API_KEY}"}}'

Source: VS Code MCP configuration reference, VS Code approvals and permissions and VS Code MCP extension guide, checked 2026-11-05. The inputs field in an install link is read by VS Code's install handler (VS Code source, mcpWorkbenchService.ts); the guide's example shows only the server fields.

Codex CLI

The Codex CLI, the Codex IDE extension and the Codex features of the ChatGPT desktop app (not chats in ChatGPT) share one Codex configuration, ~/.codex/config.toml, or .codex/config.toml in a trusted project. Codex reads the Queue CallBack API key from the environment variable you name, so the file holds only the name QCB_API_KEY:

[mcp_servers.queuecallback]
url = "https://mcp.queuecallback.com/mcp"
bearer_token_env_var = "QCB_API_KEY"
default_tools_approval_mode = "writes"

Or add the server with a command, then add the default_tools_approval_mode line to the file yourself:

codex mcp add queuecallback --url https://mcp.queuecallback.com/mcp --bearer-token-env-var QCB_API_KEY

• bearer_token_env_var sends Authorization: Bearer <value of QCB_API_KEY>.
• default_tools_approval_mode = "writes" makes Codex ask before every tool that is not marked read-only. The Queue CallBack MCP server marks each of its read tools read-only.
• codex mcp list shows the configured servers. In the Codex terminal UI, /mcp shows the active servers.

Source: Codex MCP docs (redirects to learn.chatgpt.com), checked 2026-11-05. The --bearer-token-env-var flag is defined in the Codex CLI source (codex-rs/cli/src/mcp_cmd.rs).

Gemini CLI

Gemini CLI reads the Queue CallBack MCP server from ~/.gemini/settings.json (user) or .gemini/settings.json (project) and resolves ${QCB_API_KEY} when it loads the settings:

{
  "mcpServers": {
    "queuecallback": {
      "httpUrl": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer ${QCB_API_KEY}"
      }
    }
  }
}

• Use httpUrl, the Streamable HTTP field. In Gemini CLI, url means the older SSE transport.
• Leave trust unset. With "trust": true, Gemini CLI skips every tool confirmation for the server, including for tools that change data or place calls.

Or add the server with a command. The default scope is project, so pass -s user for all projects. The same command works in PowerShell:

gemini mcp add -s user --transport http --header 'Authorization: Bearer ${QCB_API_KEY}' queuecallback https://mcp.queuecallback.com/mcp

Keep the single quotes so settings.json stores the reference ${QCB_API_KEY}. With double quotes, the shell writes the key itself into the file.

Source: Gemini CLI MCP servers and Gemini CLI configuration, checked 2026-11-05.

Claude Desktop

For read-only use, Claude Desktop needs no API key: add the Queue CallBack connector and sign in (Sign in from Claude). To use an API key in Claude Desktop, for changes, calls or unmasked caller data, connect through the mcp-remote bridge. The bridge is a small local program that forwards Claude Desktop's requests to the Queue CallBack MCP server and adds your header. A custom connector in Claude's settings can send an API key only in organizations that have the Request headers beta.

Option A: the mcp-remote bridge

The bridge needs Node.js 18 or later. Claude Desktop runs it with your system's Node.js.

1. Open claude_desktop_config.json:

   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows: %APPDATA%\Claude\claude_desktop_config.json

   If the file does not exist yet, you may need to turn it on under Settings > Developer in Claude Desktop.

2. Add the server. On macOS:

   {
     "mcpServers": {
       "queuecallback": {
         "command": "npx",
         "args": [
           "-y",
           "mcp-remote@0.16.0",
           "https://mcp.queuecallback.com/mcp",
           "--transport",
           "http-only",
           "--header",
           "Authorization: Bearer ${QCB_API_KEY}"
         ],
         "env": {
           "QCB_API_KEY": "qcb_sk_..."
         }
       }
     }
   }
   

   On Windows, Claude Desktop does not escape spaces inside args. Put the whole header value, with its space, in the env block, and write the argument with no space after the colon:

   {
     "mcpServers": {
       "queuecallback": {
         "command": "npx",
         "args": [
           "-y",
           "mcp-remote@0.16.0",
           "https://mcp.queuecallback.com/mcp",
           "--transport",
           "http-only",
           "--header",
           "Authorization:${QCB_AUTH_HEADER}"
         ],
         "env": {
           "QCB_AUTH_HEADER": "Bearer qcb_sk_..."
         }
       }
     }
   }
   

3. Quit Claude Desktop completely and open it again.

• mcp-remote replaces ${...} in its arguments with values from its env block. The key is in plain text in claude_desktop_config.json. Keep that file private and update it when you rotate the key.
• To keep the key out of the process list, put the header in a file and pass --header-file <path> instead of --header and its value. The file holds one line: Authorization: Bearer qcb_sk_....
• Pin the mcp-remote version you have tested. 0.16.0 is the current release on 2026-11-05.

Option B: a custom connector with Request headers (beta)

Anthropic describes request header authentication as "in beta and available to a limited set of organizations". If the Add custom connector dialog has no Request headers section, your organization does not have the beta. A custom connector then cannot send a Queue CallBack API key: sign in instead for read-only access (Sign in from Claude), or use Option A in Claude Desktop.

1. On a Free, Pro, Max or Ultra plan, open Customize > Connectors, choose + Add, then Add custom connector. On a Team or Enterprise plan, an Owner opens Organization settings > Connectors, chooses Add, hovers over Custom and selects Web.
2. Enter the name Queue CallBack and the MCP server URL https://mcp.queuecallback.com/mcp, then choose Continue and review the detected settings.
3. For Authentication, choose No sign in.
4. Open Request headers, choose the header name authorization, and enter the value Bearer qcb_sk_.... Type Bearer and a space before the key: Claude sends the value exactly as entered and adds no scheme.
5. Mark the header Required and click Add.

• Claude connects to the server from Anthropic's cloud, not from your computer. The connector works in claude.ai, Cowork, Claude Desktop and the Claude mobile apps.
• On Team and Enterprise plans, everyone who uses the connector reaches Queue CallBack with that same key. Give the key only the scopes every member may use, for example read scopes only. See Scopes. If members only need to read, a sign-in connector is the better choice: each member then acts as themselves.
• You cannot change a connector's headers after you add it. To change the key, remove the connector and add it again.
• A connector cannot both send an Authorization header and sign in.
• The pre-filled links in Sign in from Claude open the same dialog. They never carry the key.

Source: mcp-remote README, Add a connector that isn't in the directory, Directory connectors vs custom connectors and Get started with custom connectors, checked 2026-11-05.

Devin Desktop (formerly Windsurf)

Windsurf is now Devin Desktop. Its local agent reads MCP servers from ~/.config/devin/mcp_config.json (Windows: %APPDATA%\devin\mcp_config.json) and resolves ${env:NAME} in url and headers, so the Queue CallBack API key stays in QCB_API_KEY:

{
  "mcpServers": {
    "queuecallback": {
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:QCB_API_KEY}"
      }
    }
  }
}

• For one project, use .devin/mcp_config.json, which is meant to be committed. Put anything secret in .devin/mcp_config.local.json, which is gitignored.
• Devin Desktop asks before every MCP tool call by default. To allow a read tool for good, add a rule such as mcp__queuecallback__get_me under Allow in the Devin Local settings. Keep the tools that change data on ask.
• Devin CLI: devin mcp add -s user queuecallback https://mcp.queuecallback.com/mcp adds the server to the same user file. Add the headers block to the file afterwards.

Source: Devin Local customizations, Cascade MCP configuration, Devin CLI MCP configuration and Devin Local permissions, checked 2026-11-05.

Zed

Zed sends a fixed Authorization header to the Queue CallBack MCP server. Zed's docs show no way to reference an environment variable in a remote server's headers, so the key is written into Zed's user settings file in plain text. Add it under Settings > AI > MCP Servers, Add Server, Add Remote Server, or edit your user settings file:

{
  "context_servers": {
    "queuecallback": {
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer qcb_sk_..."
      }
    }
  }
}

• Use your user settings, not a project's .zed/settings.json that other people can read or that gets committed.
• Without an Authorization header, Zed starts an OAuth sign-in instead.
• Keep agent.tool_permissions.default at "confirm", the default, so Zed asks before each tool call.

Source: Zed MCP docs, checked 2026-11-05.

Goose

Goose connects to the Queue CallBack MCP server as a remote extension over Streamable HTTP. Add it with goose configure, Add Extension, Remote Extension (Streamable HTTP), or in ~/.config/goose/config.yaml (Windows: %APPDATA%\Block\goose\config\config.yaml):

extensions:
  queuecallback:
    type: streamable_http
    name: queuecallback
    enabled: true
    uri: https://mcp.queuecallback.com/mcp
    headers:
      Authorization: "Bearer ${QCB_API_KEY}"
    env_keys:
      - QCB_API_KEY
    timeout: 300

• Goose looks up each name in env_keys in the environment, then in its own secret store, and replaces ${QCB_API_KEY} in the header with that value. Goose's docs show the headers field; the substitution is in Goose's source (crates/goose/src/agents/extension.rs).
• Goose runs tools without asking by default (Autonomous mode). Switch to Manual Approval with /mode approve, or set GOOSE_MODE: "approve" in config.yaml, before you use tools that change data or place calls.

Source: Goose: using extensions, Goose config files and Goose permission modes, checked 2026-11-05.

Cline

Cline sends a fixed Authorization header to the Queue CallBack MCP server. Cline's docs show no way to reference an environment variable in a remote server's headers, so the key is written into the settings file in plain text. In the IDE extension, open the Cline panel, click the MCP Servers icon, open Configure and click Configure MCP Servers. The Cline CLI uses ~/.cline/data/settings/cline_mcp_settings.json.

{
  "mcpServers": {
    "queuecallback": {
      "type": "streamableHttp",
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer qcb_sk_..."
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

• Set "type": "streamableHttp". Without type, Cline uses the older SSE transport.
• Put only read tools, such as get_me, in autoApprove. Leave out every tool that changes data or places calls.
• Cline CLI (bash or zsh): cline mcp add queuecallback https://mcp.queuecallback.com/mcp --transport http --header "Authorization: Bearer $QCB_API_KEY" --yes. In PowerShell, write $env:QCB_API_KEY in place of $QCB_API_KEY. Either way the shell inserts the key, so it is stored in plain text in the settings file.

Source: Cline MCP docs, checked 2026-11-05.

JetBrains

JetBrains IDEs have two AI agents, AI Assistant and Junie, and they connect to the Queue CallBack MCP server in different ways.

JetBrains AI Assistant

The documented remote form for AI Assistant takes a url and no headers, so use the mcp-remote bridge. It needs Node.js 18 or later. Open Settings | Tools | AI Assistant | Model Context Protocol (MCP), click Add, and paste:

{
  "mcpServers": {
    "queuecallback": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@0.16.0",
        "https://mcp.queuecallback.com/mcp",
        "--transport",
        "http-only",
        "--header",
        "Authorization:${QCB_AUTH_HEADER}"
      ],
      "env": {
        "QCB_AUTH_HEADER": "Bearer qcb_sk_..."
      }
    }
  }
}

The argument has no space after the colon, and the space after Bearer lives in the env value. This is the form the mcp-remote README gives for clients that do not escape spaces inside args. The key is in plain text in the IDE's MCP configuration.

JetBrains Junie

Junie in the IDE and the Junie CLI share one MCP configuration. Put the server in the user-scope file ~/.junie/mcp/mcp.json, not in a project's .junie/mcp/mcp.json, which may be committed. Junie's docs show no way to reference an environment variable in a remote server's headers, so the key is in plain text:

{
  "mcpServers": {
    "queuecallback": {
      "url": "https://mcp.queuecallback.com/mcp",
      "headers": {
        "Authorization": "Bearer qcb_sk_..."
      }
    }
  }
}

In the Junie CLI, /mcp lists the configured servers.

Source: AI Assistant MCP docs (AI Assistant 2026.2), Junie MCP configuration and mcp-remote README, checked 2026-11-05.

Automation and other clients

On n8n, Zapier and Make, one connection to the Queue CallBack MCP server is shared by every workflow that uses it, and calls run with no person watching. Give the key only the scopes the automation needs, usually read scopes. Leave out callbacks:dial (requeue_callback places real calls), ivr:publish (changes what callers hear) and queues:write (changes live queue settings) unless the automation must do exactly that. Do not give one key both callbacks:write and pii:read unless it must add callbacks: together they list add_callback, which places real calls. See Scopes.

All sources were checked 2026-11-05.

Continue: its configuration reference documents requestOptions headers for streamable-http MCP servers, but its docs do not say how a ${{ secrets.NAME }} reference is resolved. Queue CallBack has not documented a Continue setup yet.

SDKs

Your own program can connect to the Queue CallBack MCP server with the official MCP SDKs. Both examples read the key from QCB_API_KEY and call get_me.

TypeScript (MCP TypeScript SDK v2)

npm install @modelcontextprotocol/client

The SDK needs Node.js 20 or later. Save as check.mts and run npx tsx check.mts:

import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
import type { AuthProvider } from '@modelcontextprotocol/client';

const apiKey = process.env.QCB_API_KEY;
if (!apiKey) throw new Error('Set QCB_API_KEY first');

// The transport calls token() before every request and sends "Authorization: Bearer <token>".
const authProvider: AuthProvider = { token: async () => apiKey };
const transport = new StreamableHTTPClientTransport(new URL('https://mcp.queuecallback.com/mcp'), { authProvider });
const client = new Client({ name: 'my-app', version: '1.0.0' });

await client.connect(transport);
const result = await client.callTool({ name: 'get_me', arguments: {} });
console.log(result.structuredContent);
await client.close();

@modelcontextprotocol/client 2.4.0 is the current release on 2026-11-05. Coming from v1 (@modelcontextprotocol/sdk): the class names are the same, and the import path changed.

Source: TypeScript SDK: connect and TypeScript SDK: machine auth, checked 2026-11-05.

Python (MCP Python SDK 2.x)

pip install "mcp>=2.3"

import asyncio
import os

import httpx2
from mcp import Client
from mcp.client.streamable_http import streamable_http_client


async def main() -> None:
    async with httpx2.AsyncClient(
        headers={"Authorization": f"Bearer {os.environ['QCB_API_KEY']}"},
        timeout=httpx2.Timeout(30.0, read=300.0),
    ) as http_client:
        transport = streamable_http_client("https://mcp.queuecallback.com/mcp", http_client=http_client)
        async with Client(transport) as client:
            result = await client.call_tool("get_me", {})
            print(result.structured_content)


asyncio.run(main())

• In version 2, streamable_http_client no longer takes headers=. Headers, auth and timeouts go on the httpx2.AsyncClient you pass in.
• Keep the timeout. Without it, httpx2 waits only 5 seconds by default. Queue CallBack reporting tools may take up to 40 seconds, and edit_flow_draft, publish_flow and restore_flow_version up to 60 seconds.
• mcp 2.3.0 is the current release on 2026-11-05. It needs Python 3.10 or later.

Source: Python SDK: client transports, checked 2026-11-05.

Model APIs

The Anthropic Messages API and the OpenAI Responses API can call the Queue CallBack MCP server for you during a model request. The call to the server runs from the provider's cloud, with the key you pass in the request. Both examples read the Queue CallBack key from QCB_API_KEY; the provider's own key (ANTHROPIC_API_KEY, OPENAI_API_KEY) is a different key, read by the provider's SDK.

Anthropic Messages API (MCP connector, beta)

import os

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY, Anthropic's own key
response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1000,
    messages=[{"role": "user", "content": "Call get_me and tell me which organization and scopes this connection has."}],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://mcp.queuecallback.com/mcp",
            "name": "queuecallback",
            "authorization_token": os.environ["QCB_API_KEY"],
        }
    ],
    tools=[
        {
            "type": "mcp_toolset",
            "mcp_server_name": "queuecallback",
            "default_config": {"enabled": False},
            "configs": {
                "get_me": {"enabled": True},
                "list_queues": {"enabled": True},
                "get_callback_summary": {"enabled": True},
            },
        }
    ],
    betas=["mcp-client-2025-11-20"],
)
print(response.content)

• Pass the key alone in authorization_token, without Bearer . The connector sends it as a bearer token in the Authorization header.
• The Messages API has no approval step for MCP tool calls. Anthropic recommends turning off write tools for read-only assistants, or wherever a person must confirm a change. The example allowlists three read tools (default_config off, then configs per tool). Use a key with read scopes only as well.
• On the Claude API, you can send betas=["mcp-client-2026-09-15"] in place of mcp-client-2025-11-20. It includes everything in the older header and adds pinning of a server's tool list. The Queue CallBack tool list depends on the key, and the IVR tools are Preview, so pinning keeps a conversation's tools stable. With it, a response can start with mcp_tool_listing blocks: send the assistant message back unchanged, those blocks included. Claude Platform on AWS, Claude Models on Google Cloud and Microsoft Foundry accept only mcp-client-2025-11-20, the header the example uses.

Source: Anthropic MCP connector, checked 2026-11-05.

OpenAI Responses API (mcp tool)

import os

from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY, OpenAI's own key
response = client.responses.create(
    model="gpt-6-astra",
    input="Call get_me and tell me which organization and scopes this connection has.",
    tools=[
        {
            "type": "mcp",
            "server_label": "queuecallback",
            "server_url": "https://mcp.queuecallback.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['QCB_API_KEY']}"},
            "allowed_tools": {"read_only": True},
            "require_approval": "never",
        }
    ],
)
print(response.output_text)

• headers sends the header exactly as given. The separate authorization field is meant for OAuth access tokens.
• allowed_tools: {"read_only": true} imports only the tools that the server marks read-only. The Queue CallBack MCP server marks each of its read tools that way.
• require_approval defaults to "always". The example sets "never" because only read tools are imported. If you allow tools that change data, keep "always" and answer each mcp_approval_request item.

Source: OpenAI MCP tool guide and Responses API reference, checked 2026-11-05.

Clients that cannot connect yet

Apart from ChatGPT, every client with a setup on this page connects to the Queue CallBack MCP server with an API key in an Authorization: Bearer header. Claude and ChatGPT can sign in with a Queue CallBack account instead, read-only. Queue CallBack supports sign-in from those two clients only. These cases cannot connect, or cannot do everything:

Source: ChatGPT custom MCP server, ChatGPT plugin authentication and Add a connector that isn't in the directory, checked 2026-11-05.

Check the connection

Check any client's connection to the Queue CallBack MCP server with the get_me tool. get_me needs no scope and changes nothing. It answers for every active key and every signed-in connection. Otherwise the request fails with 401 invalid_token or 403 mcp_disabled (see Troubleshooting).

1. Ask the client: "Use the queuecallback get_me tool and tell me which organization, role and scopes this connection has."
2. For an API key, compare the answer with the key in the portal: Settings, then Manage API keys. The key's Name must match api_key.name, and the Key column (qcb_sk_...abcd) must end in api_key.last4. For a sign-in from Claude or ChatGPT, check that actor_type is oauth and that organization_id is your organization; get_organization gives its name.

Some clients show the server's own title, Queue CallBack.

A get_me answer for an API key looks like this (placeholder values):

{
  "actor_type": "api_key",
  "user_id": "apikey:00000000-0000-0000-0000-000000000000",
  "organization_id": "11111111-1111-1111-1111-111111111111",
  "role": "org_admin",
  "scopes": ["callbacks:read", "org:read", "queues:read", "reports:read"],
  "pii_allowed": false,
  "custom_ivr_enabled": false,
  "ivr_reporting_enabled": false,
  "api_key": {
    "id": "00000000-0000-0000-0000-000000000000",
    "name": "Claude Code",
    "prefix": "qcb_sk",
    "last4": "abcd",
    "minted_by": "...a1b2c3",
    "created_at": "2026-11-05T09:00:00Z",
    "expires_at": "2027-02-03T09:00:00Z"
  },
  "delegation": null
}

A get_me answer for a sign-in from Claude or ChatGPT looks like this (placeholder values):

{
  "actor_type": "oauth",
  "user_id": "<your user id>",
  "organization_id": "11111111-1111-1111-1111-111111111111",
  "role": "user",
  "scopes": ["callbacks:read", "org:read", "queues:read", "reports:read"],
  "pii_allowed": false,
  "custom_ivr_enabled": false,
  "ivr_reporting_enabled": false,
  "api_key": null,
  "delegation": {
    "act": "oauth",
    "issued_at": "2026-11-05T09:00:00Z",
    "expires_at": "2026-11-05T09:02:00Z"
  }
}

What custom_ivr_enabled: false means

custom_ivr_enabled: false means the organization does not have the Custom IVR add-on. The IVR flow tools (flows, node types, drafts, validation and publishing) are not listed, and no ivr: scope takes effect, even if the key holds one. The queue, callback and callback report tools work as usual. The IVR call reports belong to the add-on too; ivr_reporting_enabled says whether this connection reads them. To add the IVR flow tools, see IVR flow tools.

Tools you see

The tools a client lists depend on the key's scopes, or for a sign-in on the five read scopes and the person's role, on the organization, and, for the five IVR report tools, on ivr_reporting_enabled. Queue CallBack can also switch changes off on the server; while they are off, clients see only the read-only tools. After a change to a key, its scopes, the organization or a server switch, the tool list can take up to about 90 seconds to update: the server reuses a key's description for up to 30 seconds, and clients may cache the list for up to 60 seconds. Reconnect the client to refresh it. The full list, with the scopes each tool needs, is in the tool reference.

Check without an AI client

This request calls get_me directly (bash or zsh):

curl -sS https://mcp.queuecallback.com/mcp \
  -H "Authorization: Bearer $QCB_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "MCP-Protocol-Version: 2025-11-25" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_me","arguments":{}}}'

A working key returns one JSON-RPC response whose result.structuredContent holds the get_me object shown above. Both Content-Type: application/json and an Accept header that lists application/json and text/event-stream are required.

Troubleshooting

Fixes for a client that cannot reach the Queue CallBack MCP server are on the Troubleshooting page:

Every HTTP and tool error code is on Errors, starting at HTTP errors.