Quickstart

Supernova gives AI agents the tools to take any action on your users’ online accounts, both actions that require user authentication and those that don’t, such as searching for products, building a cart, and checking out. Your agent connects to the Supernova MCP server with an MCP token you create for each user. For actions requiring authentication, users link their accounts once and your agent can then take those actions.

Supernova is in early access and runs in production only. Join the waitlist to get access.

Connection details


Server URL	`https://supernova-mcp.knotapi.com/mcp`
Transport	Streamable HTTP
Authentication	`Authorization: Bearer sn_prod_...` with an MCP token for one user

An MCP token acts as the one user you created it for. The agent can reach only that user’s accounts and the sites enabled for your Knot account.

Get your API key

In the Knot Dashboard, retrieve your client_id and secret and base64 encode them to create your API key. Docs here for further details.

Create an MCP token for a user

From your backend, call Create MCP Token with your client_id and secret as Basic auth. Supernova can perform both unauthenticated and authenticated (i.e. behind a login) actions online. To enable authenticated actions (recommended), providing the user’s phone_number when creating the MCP token is required, so the Supernova MCP can create sign-in links.

Request

curl --request POST \
  --url https://production.knotapi.com/mcp/tokens/create \
  --user "$KNOT_CLIENT_ID:$KNOT_SECRET" \
  --header 'Content-Type: application/json' \
  --data '{
    "external_user_id": "123abc",
    "phone_number": "+12025550123",
    "expires_in": 86400
  }'

Response

{
  "token": "sn_prod_wyLZTDc3_HzXo5lcRkkbZpnmFfg5DU63nHnUsyPQbi0",
  "expires_at": "2026-10-27T15:30:00Z"
}

The token acts for that one user. Keep your client_id and secret on your backend and give your agent only the MCP token. Tokens last 1 day by default and up to 30 days. Call Revoke MCP Tokens to revoke all of a user’s tokens.

Add the Supernova MCP to your agent

Point your MCP client at https://supernova-mcp.knotapi.com/mcp over Streamable HTTP and send the MCP token in the Authorization header as Bearer sn_prod_....

Try it locally

The fastest way to try Supernova is to add it to a coding agent on your machine. Save your API key to your shell:

Save your API key

case "$SHELL" in */zsh) f=~/.zshrc;; */bash) f=~/.bashrc;; *) f=~/.profile;; esac; touch "$f" \
  && sed -i.bak '/^export KNOT_API_KEY=/d' "$f" && rm -f "$f.bak" \
  && printf 'export KNOT_API_KEY=%s\n' '<your API key>' >> "$f" && export KNOT_API_KEY='<your API key>'

Then paste this prompt into your coding agent. It asks for your phone number, creates an MCP token, saves it to your shell, and adds the server:

Setup prompt

Set up the Supernova MCP server so you can act on my accounts at online sites.
My Knot API key is in the KNOT_API_KEY environment variable. Use it only to create my MCP token below, and never print it or the token.

1. Ask me for my mobile number (US or Canada). Supernova texts it a code when I sign in to a site.
2. Create my MCP token: POST https://production.knotapi.com/mcp/tokens/create with the header "Authorization: Basic <KNOT_API_KEY>" and the body {"external_user_id": "<my username on this machine>", "phone_number": "<my number in E.164>"}. Save the token as SUPERNOVA_MCP_TOKEN in my shell profile, the same way KNOT_API_KEY is saved. It lasts 1 day; create a new one when it expires.
3. Add the MCP server https://supernova-mcp.knotapi.com/mcp (Streamable HTTP) to the client you're running in, named supernova, with the header "Authorization: Bearer <SUPERNOVA_MCP_TOKEN>". Restart if the supernova tools don't load.
4. Call supernova_list_sites, tell me which sites I can use, and suggest a few tasks.
5. When a site needs me to sign in, send me the link Supernova returns. Never ask for my password or the code texted to me.

Docs for agents: https://docs.knotapi.com/llms.txt

Or set SUPERNOVA_MCP_TOKEN to a token from step 2 and add the server yourself:

Claude Code
Codex
Cursor
VS Code

claude mcp add --transport http supernova https://supernova-mcp.knotapi.com/mcp \
  --header "Authorization: Bearer $SUPERNOVA_MCP_TOKEN"

Codex reads the token from SUPERNOVA_MCP_TOKEN each time it starts:

codex mcp add supernova --url https://supernova-mcp.knotapi.com/mcp \
  --bearer-token-env-var SUPERNOVA_MCP_TOKEN

Add the server to .cursor/mcp.json:

{
  "mcpServers": {
    "supernova": {
      "url": "https://supernova-mcp.knotapi.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SUPERNOVA_MCP_TOKEN}"
      }
    }
  }
}

Add the server to .vscode/mcp.json. VS Code asks for the token when it starts the server:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "supernova-mcp-token",
      "description": "Supernova MCP token",
      "password": true
    }
  ],
  "servers": {
    "supernova": {
      "type": "http",
      "url": "https://supernova-mcp.knotapi.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:supernova-mcp-token}"
      }
    }
  }
}

Add it to your deployment env

When you’re ready, connect the Supernova MCP to your user-facing agent, from the server where it runs. Your backend creates an MCP token for each user and passes it to your agent’s MCP client. Create the token when the user starts a conversation, reuse it until its expires_at, and never send it to your client app.

Claude API
OpenAI API
TypeScript
Python

The MCP connector connects Claude to Supernova from the Messages API:

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    betas=["mcp-client-2025-11-20"],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://supernova-mcp.knotapi.com/mcp",
            "name": "supernova",
            "authorization_token": supernova_mcp_token,
        }
    ],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "supernova"}],
    messages=[{"role": "user", "content": "Which of my merchant accounts are linked?"}],
)

The remote MCP tool connects OpenAI models to Supernova from the Responses API:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "supernova",
            "server_url": "https://supernova-mcp.knotapi.com/mcp",
            "authorization": supernova_mcp_token,
            "require_approval": "never",
        }
    ],
    input="Which of my merchant accounts are linked?",
)

With the MCP TypeScript SDK (@modelcontextprotocol/client):

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

const client = new Client({ name: 'my-agent', version: '1.0.0' });
const transport = new StreamableHTTPClientTransport(new URL('https://supernova-mcp.knotapi.com/mcp'), {
  requestInit: { headers: { Authorization: `Bearer ${supernovaMcpToken}` } },
});
await client.connect(transport);

const { tools } = await client.listTools();
const result = await client.callTool({ name: 'supernova_list_accounts', arguments: {} });
console.log(result.structuredContent);

await client.close();

With the MCP Python SDK (mcp):

from mcp import Client
from mcp.client.streamable_http import create_mcp_http_client, streamable_http_client

http_client = create_mcp_http_client(headers={"Authorization": f"Bearer {supernova_mcp_token}"})
transport = streamable_http_client("https://supernova-mcp.knotapi.com/mcp", http_client=http_client)

async with Client(transport) as client:
    tools = await client.list_tools()
    result = await client.call_tool("supernova_list_accounts", {})
    print(result.structured_content)

Interact with Supernova in your agent

Ask your agent to do something on a site, such as “Find me some tasty ice cream.” If the action requires authentication to an online account and an account is not linked, your agent gets a sign-in link from the Supernova MCP and will return it to you to sign-in.

Linking online accounts

Some actions need the user’s own account at a site. The agent calls supernova_list_accounts and supernova_link_account to check whether the user has a linked account there. If not, it gets a sign-in link and returns it to the user in the UI, the user confirms a code texted to their phone, and signs in to the site. The agent never asks for the user’s username or password to the site. OTP codes are texted to the phone number provided in Create MCP Token.

Running actions

The agent sends the user’s request to supernova_do in plain language. Supernova routes it to the right action, runs it, and returns only the fields the request needs. Some sites also support guest actions, such as searching without signing in. The agent creates a guest session with supernova_create_guest_session and passes its ID as session.

General

Supernova

SDK

CardSwitcher

SubscriptionManager

TransactionLink

Detect

Vaulting

Shopping

Merchant Account Linking

Connection details

Get your API key

Create an MCP token for a user

Add the Supernova MCP to your agent

Try it locally

Add it to your deployment env

Interact with Supernova in your agent

Linking online accounts

Running actions

​Connection details

Get your API key

Create an MCP token for a user

Add the Supernova MCP to your agent

​Try it locally

​Add it to your deployment env

Interact with Supernova in your agent

​Linking online accounts

​Running actions

Connection details

Try it locally

Add it to your deployment env

Linking online accounts

Running actions