How to Connect Claude, Cursor, or Any MCP Client to Your Business Systems in Under 5 Minutes

HeadlessOps

Sign in Get Started

If you want to connect Claude, Cursor, or any MCP client to systems that actually run your business — CRMs, webhooks, scheduled jobs, data stores — the setup is one config block and one authorization click, not a new API to learn. This is a genuine step-by-step walkthrough, not a teaser for documentation you have to go find elsewhere: by the end of this article your AI client will be able to list, build, deploy, and debug real automations running on HeadlessOps, and you’ll have concrete prompts to try immediately.

What MCP Actually Is (Briefly)

The Model Context Protocol (MCP) is an open standard, introduced by Anthropic, for connecting AI assistants to external tools and data sources through a consistent interface. Instead of every platform inventing its own plugin format, an MCP server exposes a set of typed “tools” — discrete operations like “list integrations” or “trigger a run” — that any MCP-compatible client can call. Your AI assistant doesn’t need a custom integration built for each platform it talks to; it needs one MCP connection, and it can see and use every tool that server exposes.

For business automation specifically, this matters because it changes who — or what — builds the automation. A workflow builder UI requires a human to click through screens, map fields, and configure a trigger, one visual step at a time. An MCP connection lets an AI agent read your intent in natural language and directly call the same underlying create-deploy-run operations a human would use through a UI — meaning your AI client can be the one writing and shipping the integration, not just describing what a human should build next.

HeadlessOps runs a native MCP server for exactly this purpose. Connect any MCP-compatible AI client to it, and that client can create integrations, push code, deploy, trigger runs, read step-level logs, manage credentials, and query data stores — the full operational surface of the platform, available through conversation.

The General Connection Pattern

Every MCP client connects to HeadlessOps the same way, because there’s a single server endpoint and a single authentication model:

Server URL:

https://app.headlessops.ai/mcp

Authentication: OAuth 2.1 with PKCE — no API key to generate or paste anywhere. Authentication is user-level: each person who connects an AI client logs in with their own HeadlessOps account and receives an individual, scoped access token. When multiple people on a team each connect their own client, everyone authorizes independently under their own identity and permissions — there’s no shared secret to distribute or rotate.

The setup across every client follows the same three steps:

1. Add the server config — paste a small JSON block (or run one CLI command) pointing at the MCP URL.
2. Restart the client.
3. Authorize in the browser — a login window opens on first use; log in to HeadlessOps and approve the requested scopes.

That’s the entire pattern. The only thing that differs between Claude Desktop, Claude Code, Cursor, and every other MCP-compatible client is where you paste the config.

Connecting Claude Desktop

Claude Desktop connects to HeadlessOps directly over HTTPS — no local installation required for the basic setup.

Step 1 — Edit your config file:

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

Step 2 — Add the HeadlessOps server:

{
  "mcpServers": {
    "headlessops": {
      "url": "https://app.headlessops.ai/mcp",
      "type": "http"
    }
  }
}

Step 3 — Restart Claude Desktop, open a new conversation, and authorize. Claude will prompt you to connect; a browser window opens, you log in to HeadlessOps, and grant the requested scopes. Claude is now connected and can manage your automations directly.

If you have multiple HeadlessOps workspaces, create an iterator/iterator.config.json file in your project repository with { "workspaceId": "ws_abc123" }, and Claude will automatically resolve to that workspace whenever it works inside that repo. If you’re unsure of your workspace ID, just ask: “List my workspaces” — Claude calls the workspaces_list tool and shows you the available options.

For agent workflows that need to read and write local files directly — downloading integration code, editing it, and pushing an updated version — install the local proxy package (npm install -g @headlessops-ai/mcp) and swap the url config for a command/args pair pointing at the headlessops-mcp binary. This unlocks the folderPath parameter so Claude can work with files on your machine instead of passing code inline in every tool call.

Connecting Claude Code

Claude Code, Anthropic’s agentic CLI, supports MCP natively and connects in a single command.

Option A — One command:

claude mcp add headlessops --transport http https://app.headlessops.ai/mcp

Claude Code adds the server automatically and opens your browser to authorize on first use.

Option B — Manual config, if you prefer editing the file directly (~/.claude/claude_desktop_config.json on macOS/Linux, %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "headlessops": {
      "url": "https://app.headlessops.ai/mcp",
      "type": "http"
    }
  }
}

Restart Claude Code and authorize when prompted. As with Claude Desktop, install the @headlessops-ai/mcp local proxy if you want Claude Code to read and write integration files directly in your working directory rather than passing everything inline — this is the natural mode for Claude Code specifically, since you’re already working in a terminal against a local repo.

Connecting Cursor

Cursor supports MCP servers through its settings UI.

Step 1 — Open Cursor Settings → Features → Model Context Protocol.

Step 2 — Add a new MCP server:

{
  "name": "HeadlessOps",
  "url": "https://app.headlessops.ai/mcp",
  "type": "http"
}

Step 3 — Save settings, restart Cursor, and authorize in the browser when prompted.

For local file access (recommended for any real development work), install the proxy and point Cursor at it as a command instead of a URL:

npm install -g @headlessops-ai/mcp

{
  "name": "HeadlessOps",
  "command": "headlessops-mcp",
  "args": ["--mcp-url", "https://app.headlessops.ai/mcp"]
}

Roo Code uses the identical command/args pattern in .roo/mcp.json, and any other stdio-based client (Windsurf, VS Code with GitHub Copilot, Codex) follows the same shape — a url config for the simplest remote connection, or a command pointing at headlessops-mcp when you need the client to touch local files. If your client isn’t one of the three covered here in detail, the same two-option pattern applies; it’s genuinely the same JSON block everywhere.

Workspace Resolution — One File, Set Once

Regardless of which client you connect, if you belong to more than one HeadlessOps workspace, create iterator/iterator.config.json in your project’s repository root:

{ "workspaceId": "ws_abc123" }

Every MCP tool call your AI client makes while working in that repository resolves to this workspace automatically — you don’t need to specify it in every prompt. If this file doesn’t exist and your account has multiple workspaces, your AI client will ask workspaces_list first and either match the repo name against a workspace slug or ask you directly, rather than guessing.

What Your AI Can Now Do

Once connected, you’re not just chatting about automation — your AI client has direct tool access to build, deploy, and operate it. Some concrete prompts to try immediately after connecting:

Inspect what’s already running:

• “List all my integrations.”
• “Show me the last 10 failed runs of crm-sync.”
• “What files does the invoice-processor integration have?”

Build and deploy something new:

• “Create a workflow that syncs new HubSpot contacts to Slack every morning.”
• “Write a scheduled integration that runs every Monday at 9am and sends a Slack summary of last week’s sales.”
• “Create a webhook integration that logs incoming payloads and saves them to a data store.”
• “Deploy a manual integration that fetches a contact from HubSpot by email.”

Debug a failure without leaving the conversation:

• “The crm-sync integration failed — read the logs and fix the error.”
• “Check the last run of daily-report and tell me what happened in step 2.”

Manage state:

• “Create a data store called processed-invoices with columns: invoice_id (TEXT), amount (NUMBER), processed_at (DATE).”
• “List all data stores in my workspace.”

Each of these is a real tool call, not a hypothetical. When you ask your AI client to fix a failing integration, it calls integration_files_list to see what exists, reads the actual step-level run logs to find the error, edits the code, and calls integration_files_push_run to redeploy and test — the same lifecycle a human developer would follow, executed end-to-end by the AI. That’s the practical difference between an MCP connection and a chatbot that can only describe what you should click next: your AI client is the one taking the action.

A Note on Credentials

Connecting your AI client via MCP does not mean your AI ever sees your API keys or secrets in plaintext. Credentials in HeadlessOps are referenced by name inside integration code (ctx.credentials.STRIPE_KEY, for example) — the AI writes and reads that reference, but the actual secret value is resolved at runtime inside the platform, never passed through the model’s context. This is a deliberate part of the credential model, not an incidental side effect, and it’s worth understanding before you connect an AI client to systems that touch production data.

Getting Started

The setup described above takes most people under five minutes, and none of it requires an API key — OAuth handles authentication end to end. If you want the full tool reference (every MCP tool HeadlessOps exposes, scopes, and label-based access rules), see the MCP Setup Overview. If you’re deciding whether an AI-builds-the-integration model like this fits your team better than a visual drag-and-drop builder, our comparison against Zapier covers that tradeoff directly and fairly.

Once connected, the fastest way to see the value is to just ask for something real: describe an automation you actually need, in plain language, and watch your AI client build it.