Direct MCP connection with device login

Connect external tools straight to the CorpusIQ MCP server at mcp2.corpusiq.io, without going through ChatGPT, Claude, or Perplexity. CLI tools, agents, CI runners, and IDE plugins sign in once with OAuth 2.0 device login, receive a bearer token, and reach every connector you have already authorized. No embedded browser. No client secret to store. Copy the config, run the helper, export the token.

Connection details

The MCP server is online at the endpoint below. Browser-based clients use OAuth and open a sign-in window. CLI tools and agents use device login. Both reach the same server and the same 36+ connectors.

https://mcp2.corpusiq.io/mcp

https://www.corpusiq.io/mcp-auth

{
  "mcpServers": {
    "corpusiq": {
      "url": "https://mcp2.corpusiq.io/mcp",
      "authorizationUrl": "https://www.corpusiq.io/mcp-auth"
    }
  }
}

Browser OAuth clients

ChatGPT, Claude, and Perplexity open a browser window to authenticate. No bearer token needed. Add the server URL above, sign in, and your connectors are live in the assistant.

Agent and CLI tools: device login

CLI tools, agent loops, and CI runners cannot open a browser. These use the OAuth 2.0 Device Authorization Grant. A short code is shown, you sign in once, and the tool receives a token it sends as an Authorization Bearer header on every call to the MCP endpoint.

Device-login helper

Drop this into your project. It has no dependencies beyond requests. Run it, sign in with the printed code, and it prints the access token for you to export.

# device_login.py -- CorpusIQ MCP device-login helper
# No dependencies beyond requests
from __future__ import annotations
import sys, time
from typing import Any
import requests

DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code"

class DeviceLoginError(RuntimeError):
    pass

def login(base_url: str = "https://mcp2.corpusiq.io", timeout: int = 30) -> dict[str, Any]:
    s = requests.Session()
    r = s.post(f"{base_url}/oauth/device/authorize", timeout=timeout)
    r.raise_for_status()
    dc = r.json()
    print(
        f"\nSign in to CorpusIQ:\n"
        f"  Open:  {dc['verification_uri']}\n"
        f"  Code:  {dc['user_code']}\n",
        flush=True,
    )
    interval = int(dc.get("interval", 5))
    deadline = time.time() + int(dc.get("expires_in", 900))
    while time.time() < deadline:
        time.sleep(interval)
        tr = s.post(
            f"{base_url}/oauth/token",
            data={"grant_type": DEVICE_GRANT, "device_code": dc["device_code"]},
            timeout=timeout,
        )
        if tr.status_code == 200:
            return tr.json()
        err = (tr.json() if tr.headers.get("content-type","").startswith("application/json") else {}).get("error","")
        if err == "authorization_pending": continue
        if err == "slow_down": interval += 5; continue
        if err in ("expired_token", "invalid_grant"):
            raise DeviceLoginError(f"Device login failed: {err}")
        raise DeviceLoginError(f"Unexpected {tr.status_code}: {tr.text}")
    raise DeviceLoginError("Device code expired.")

if __name__ == "__main__":
    try: print(login()["access_token"])
    except DeviceLoginError as e: print(e, file=sys.stderr); sys.exit(1)

How it works

Device login follows the OAuth 2.0 Device Authorization Grant, a published IETF standard. The shape is four steps, and you only touch one of them by hand:

1. Point your tool at the MCP server. Add the CorpusIQ server to your client config. The URL is https://mcp2.corpusiq.io/mcp and the authorization URL is https://www.corpusiq.io/mcp-auth.
2. Start device login. Run your client or the device-login helper. The tool asks the server to start a session and prints a short code with a sign-in link.
3. Sign in once in a browser. Open the link on any device, sign in to CorpusIQ, and enter the short code. This confirms the tool is acting as you.
4. Use the token. The tool receives a bearer token and sends it as an Authorization header on every call to the MCP server. Your already-authorized connectors come with it.

From then on, the tool reaches the MCP server directly. No browser stays open, and nothing about the flow asks you to copy a client secret into your tool.

Two ways to connect

CorpusIQ gives you two ways in. The first is through your assistant: you authorize your connectors in the dashboard and use them inside ChatGPT, Claude, or Perplexity. That is how most people start, and nothing about it changes.

The second is a direct MCP connection. An external tool connects straight to the CorpusIQ MCP server using device login. Both paths reach the same server and the same 36+ connectors. Pick whichever fits the tool in front of you. For the side-by-side, see the features page.

When to use device login

Device login is the right path when your tool runs outside a normal browser, a terminal, a daemon, a CI runner, an IDE plugin, or an agent loop, and you do not want to store or embed an OAuth client secret. It also keeps access scoped to the actual person signing in, so your connector permissions stay tied to you rather than a shared service account.

If your tool is a standard web app, or it is ChatGPT, Claude, or Perplexity, you do not need device login. Those clients ship their own browser sign-in and connect through that.

Your connector access carries over

You authorize each connector once, in the dashboard. After that, any tool you connect with device login reaches every connector you have already authorized, with no re-linking. Once Google, Shopify, or QuickBooks is linked, a new token immediately has access to the same connectors. To review or add connectors, open your connectors in the dashboard.

Related reading

• Connect an agent to the CorpusIQ MCP server
• What is the Model Context Protocol?
• MCP Security: Protecting Your Data in the Context Window
• See all 36+ live CorpusIQ connectors

Frequently asked questions