> ## Documentation Index
> Fetch the complete documentation index at: https://docs.1eye.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Connect Claude Code, Cursor, Codex, or VS Code to the 1eye MCP server.

Connect a client, verify the workspace, and make your first read request.

## Before you begin

You need access to a 1eye workspace, an active API key for that workspace, and a client that supports Streamable HTTP MCP servers with custom authentication headers.

To create a key, open **Developers → API Keys** in 1eye. Copy the full value when it is created and store it securely. See [API Keys](https://docs.1eye.ai/api-reference/api-keys.md) for key management.

## Connect your client

Use `https://mcp.1eye.ai/mcp` as the server URL. Replace `YOUR_1EYE_API_KEY` with your key when using a literal-value example.

**Claude Code**

Run:

```bash theme={null}
claude mcp add --transport http 1eye https://mcp.1eye.ai/mcp \
  --header "Authorization: Bearer YOUR_1EYE_API_KEY" \
  --scope user
```

`--scope user` makes the connection available across your projects. The command saves the configured header in Claude Code's configuration, so protect that configuration and your shell history.

Verify the entry:

```bash theme={null}
claude mcp get 1eye
```

In Claude Code, open `/mcp` to inspect the live connection. For environment variable references and other setup options, see the [Claude Code MCP guide](https://code.claude.com/docs/en/mcp).

**Cursor**

Add this entry to your user configuration at `~/.cursor/mcp.json`. If the file already has an `mcpServers` object, merge the `1eye` entry into it.

```json theme={null}
{
  "mcpServers": {
    "1eye": {
      "url": "https://mcp.1eye.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ONEEYE_API_KEY}"
      }
    }
  }
}
```

Provide `ONEEYE_API_KEY` in the environment available to Cursor, then reload the client if needed. Open Cursor's MCP settings to confirm the server is enabled. See the [Cursor MCP guide](https://cursor.com/docs/mcp) for configuration locations and interpolation.

**Codex**

Provide `ONEEYE_API_KEY` in the environment of the Codex process, then run:

```bash theme={null}
codex mcp add oneeye \
  --url https://mcp.1eye.ai/mcp \
  --bearer-token-env-var ONEEYE_API_KEY
```

The equivalent entry in `~/.codex/config.toml` is:

```toml theme={null}
[mcp_servers.oneeye]
url = "https://mcp.1eye.ai/mcp"
bearer_token_env_var = "ONEEYE_API_KEY"
```

Verify the configuration with:

```bash theme={null}
codex mcp get oneeye
```

Then reconnect or reload the client and make the verification request below. A saved configuration alone does not prove that a live tool call works. See [Codex MCP setup](https://learn.chatgpt.com/docs/extend/mcp) for desktop, CLI, and IDE options.

**VS Code**

For the VS Code configuration format, merge this entry into `.vscode/mcp.json`:

```json theme={null}
{
  "servers": {
    "1eye": {
      "type": "http",
      "url": "https://mcp.1eye.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ONEEYE_API_KEY}"
      }
    }
  }
}
```

Provide `ONEEYE_API_KEY` in the environment of the host that connects to the server. Use VS Code's MCP controls to start the server and make its tools available to your agent. For user-level configuration and other agent harnesses, follow the [VS Code MCP reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration).

> **Environment variables:** A variable set in a terminal is available to processes launched from that terminal. A desktop app that is already running may not inherit it. Configure the variable for the actual client process, or use that client's supported secret or header helper mechanism.

## Connect a custom agent

Use a maintained MCP client SDK with a Streamable HTTP transport. Configure the server URL and Bearer header, and let the SDK handle protocol compatibility and transport details. Discover the live catalog with `tools/list`, then invoke a tool with `tools/call`, supplying its name and arguments according to the returned `inputSchema`.

The JSON examples in this documentation show tool arguments, not complete protocol messages or standalone HTTP request bodies. Use the live catalog as the source of truth when tools change. See the [MCP tool specification](https://modelcontextprotocol.io/specification/latest/server/tools) for protocol details.

## Verify the connection

Ask your assistant:

```text theme={null}
Use 1eye to retrieve my workspace profile. Tell me the workspace name,
primary domain, and time zone.
```

The assistant should call `get_workspace` with `{}` and return the expected workspace. This verifies authentication, workspace selection, and an actual tool call.

If the workspace is unexpected, check which workspace owns the key. A workspace ID is not a tool argument.

## Make your first search

```text theme={null}
Use 1eye to show up to 10 buyers added in the last seven days.
Include their names, companies, roles, and first signal type.
Tell me the exact date range and total matching buyer count.
```

To ask about activity instead:

```text theme={null}
Show buyers with website signals this week in my workspace time zone.
Count distinct buyers separately from signals and include the latest
website activity for each buyer.
```

See [workflows](https://docs.1eye.ai/mcp/workflows.md) for the difference between these searches. If tools do not appear or authentication fails, use [troubleshooting](https://docs.1eye.ai/mcp/troubleshooting.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.