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

# Connect an MCP Client

> Connect Claude Desktop or any MCP client to the Noonum MCP server using an API key or Auth0 OAuth.

New to MCP? Start with [Agentic access with MCP](/base/agentic/overview).

Connect an MCP client to the Noonum MCP server at `https://api.noonum.ai/v1/mcp`. This page covers the Claude Code CLI, Claude Desktop, Cursor, and generic MCP clients, with both authentication methods:

* API key (static `Authorization` header), for automation and server-side use.
* Auth0 OAuth, for interactive apps that sign you in through a browser.

For the full tool catalog and long-running task behavior, see the [Noonum MCP Server](/base/agentic/mcp-server) reference. For API keys and the shared REST auth model, see [Authentication](/v2/getting-started/authentication). OAuth (browser sign-in) is documented on this page.

## Before you start

| Setting      | Value                                                                      |
| ------------ | -------------------------------------------------------------------------- |
| MCP base URL | `https://api.noonum.ai/v1/mcp`                                             |
| Transport    | HTTP                                                                       |
| Auth         | `Authorization: Bearer <token>`: a Noonum API key or an Auth0 access token |

You need one of the following, depending on the method you choose:

* For the API-key flow: a Noonum API key. See [Authentication](/v2/getting-started/authentication) to request one.
* For the OAuth flow: a Noonum user account you can sign in to. The client handles the OAuth handshake, so no key is required.

<Tip>
  **Which method should I use?**
  For a script, server, or headless integration, use the API key. For a desktop app you use interactively, use Auth0 OAuth so the client signs you in through the browser.
</Tip>

## Option A — Claude Code CLI

If you use Claude Code, a single command registers the server:

```bash theme={null}
claude mcp add noonum --transport http https://api.noonum.ai/v1/mcp --header "Authorization: Bearer YOUR_API_KEY"
```

Make sure the URL ends in `/mcp`. To use the OAuth flow instead, omit `--header`. Claude Code runs the browser sign-in on first connect.

## Option B — Claude Desktop

Claude Desktop reads its MCP servers from a JSON config file.

<Steps>
  <Step title="Open the config file">
    In Claude Desktop, go to **Settings → Developer → Edit Config**. This opens (or creates) `claude_desktop_config.json`. The typical locations are:

    <Tabs>
      <Tab title="macOS">
        `~/Library/Application Support/Claude/claude_desktop_config.json`
      </Tab>

      <Tab title="Windows">
        `%APPDATA%\Claude\claude_desktop_config.json`
      </Tab>
    </Tabs>
  </Step>

  <Step title="Add the Noonum server">
    Choose the block that matches your authentication method.

    <Tabs>
      <Tab title="API key">
        Provide the key as a static `Authorization` header:

        ```json theme={null}
        {
          "mcpServers": {
            "noonum": {
              "url": "https://api.noonum.ai/v1/mcp",
              "headers": { "Authorization": "Bearer YOUR_API_KEY" }
            }
          }
        }
        ```
      </Tab>

      <Tab title="Auth0 OAuth">
        Omit `headers`; the client runs the OAuth flow on first connect:

        ```json theme={null}
        {
          "mcpServers": {
            "noonum": {
              "url": "https://api.noonum.ai/v1/mcp"
            }
          }
        }
        ```
      </Tab>
    </Tabs>

    If you already have other servers under `mcpServers`, add the `noonum` entry alongside them rather than replacing the whole object.
  </Step>

  <Step title="Restart Claude Desktop">
    Save the file and fully quit and reopen Claude Desktop so it reloads the config.

    * **API key:** the connection is established using your header.
    * **OAuth:** on the first connect the client opens a browser window for you to sign in to Noonum. After you approve, tokens are cached (encrypted at rest) and reused on later launches.
  </Step>
</Steps>

## Option C — Cursor

Cursor connects to MCP servers over HTTP. Add Noonum through **Settings → MCP → Add new MCP server**, or by editing Cursor's MCP config (`~/.cursor/mcp.json`, or `.cursor/mcp.json` for a single project). The config shape matches Claude Desktop:

<Tabs>
  <Tab title="API key">
    ```json theme={null}
    {
      "mcpServers": {
        "noonum": {
          "url": "https://api.noonum.ai/v1/mcp",
          "headers": { "Authorization": "Bearer YOUR_API_KEY" }
        }
      }
    }
    ```
  </Tab>

  <Tab title="Auth0 OAuth">
    ```json theme={null}
    {
      "mcpServers": {
        "noonum": {
          "url": "https://api.noonum.ai/v1/mcp"
        }
      }
    }
    ```
  </Tab>
</Tabs>

Reload Cursor (or toggle the server off and on) so it picks up the change. With OAuth, expect a browser prompt on first connect.

## Option D — A generic MCP client

Any MCP client that supports the MCP Streamable HTTP transport can connect to Noonum. Configuration field names vary by client; the values stay the same.

<Steps>
  <Step title="Point the client at the MCP URL">
    Set the server URL to:

    ```text theme={null}
    https://api.noonum.ai/v1/mcp
    ```

    Select the **HTTP** transport (MCP Streamable HTTP). No SSE or custom-protocol options are required.
  </Step>

  <Step title="Configure authentication">
    <Tabs>
      <Tab title="API key">
        Add a static request header:

        ```text theme={null}
        Authorization: Bearer YOUR_API_KEY
        ```

        If your client uses a JSON config, the shape generally mirrors Claude Desktop:

        ```json theme={null}
        {
          "mcpServers": {
            "noonum": {
              "url": "https://api.noonum.ai/v1/mcp",
              "headers": { "Authorization": "Bearer YOUR_API_KEY" }
            }
          }
        }
        ```
      </Tab>

      <Tab title="Auth0 OAuth">
        Leave the `Authorization` header unset. The Noonum server publishes OAuth 2.0 discovery metadata at the site root (per RFC 8414), so a compliant client can discover the authorization server and run the OAuth 2.0 Authorization Code flow with PKCE:

        * `/.well-known/oauth-authorization-server`
        * `/.well-known/oauth-protected-resource`

        On the first connect the client opens a browser for you to sign in to Noonum. After you approve, it caches the resulting tokens (encrypted at rest) and reuses them on later launches. Most compliant clients discover the values below automatically; you only need them if your client asks:

        * **Discovery:** `https://noonum.auth0.com/.well-known/openid-configuration`
        * **Issuer:** `https://noonum.auth0.com/`
        * **Audience:** `https://api.noonum.com`. Note the `.com`: it is an OAuth identifier, not the `.ai` host. Send it exactly as written.
        * **JWKS:** `https://noonum.auth0.com/.well-known/jwks.json` (RS256)
      </Tab>
    </Tabs>
  </Step>

  <Step title="Reload and connect">
    Reload the client so it picks up the new server. With OAuth, expect a browser prompt on first connect; with an API key, the connection is established immediately.
  </Step>
</Steps>

### Named examples

The steps above cover any HTTP-transport client. Two specifics:

* **Codex CLI:** register Noonum as an MCP server in your Codex config, pointed at `https://api.noonum.ai/v1/mcp` over HTTP, with the `Authorization: Bearer` header for the API-key flow.
* **ChatGPT and other connectors:** point the connector at `https://api.noonum.ai/v1/mcp`, select the HTTP transport, and set the `Authorization: Bearer` header, or leave it unset to use OAuth.

## Verify it works

Once the client has reloaded:

1. **Check the server is connected.** In Claude Desktop, open **Settings → Developer** and confirm `noonum` shows as connected. In a generic client, check its MCP server / tools panel.
2. **Confirm the tools loaded.** You should see the Noonum tools available, for example `list_strategies`, `search_companies`, and `list_premade_strategies`. The tool list means the client handshook with the server.
3. **Make a real call.** Ask the client to run a low-risk, read-only tool. Good first calls:
   * "List my Noonum strategies" → runs `list_strategies`.
   * "List Noonum premade strategies" → runs `list_premade_strategies`.

A successful tool call returns data (or an empty list if you have no strategies yet) rather than an authentication error. That confirms both the connection and your credentials are good.

<Tip>
  **Read analytics, not trades.** Noonum tools return research analytics. They don't place trades and [aren't investment advice](/base/agentic/mcp-server#disclaimer). An LLM client can also misread output, so review results before acting on them. Most tools are read-only and safe to explore first; a few change your strategies or consume credits (see [What your agent can access](/base/agentic/mcp-server#what-your-agent-can-access)). Lead with read-only calls and use the state-changing ones deliberately.
</Tip>

## Troubleshooting

### 401 Unauthorized (API key)

An API-key authentication failure returns a standard `401 Unauthorized`. Check that:

* The header is exactly `Authorization: Bearer YOUR_API_KEY`, with a single space after `Bearer` and no extra quotes or whitespace around the key.
* You pasted the **full** key and it has not been revoked. If in doubt, request a fresh key from **[hello@noonum.com](mailto:hello@noonum.com)**.
* The URL is `https://api.noonum.ai/v1/mcp` (note `.ai`, and the `/v1/mcp` path).

### OAuth re-authentication

OAuth failures do not surface as a `401` you handle yourself. Instead the client re-initiates the authorization flow and reopens the browser to sign you in again. This typically happens when a cached token has expired or been invalidated. If the browser prompt does not appear or the loop repeats:

* Complete the browser sign-in fully, including any consent screen.
* Make sure your client is configured without an `Authorization` header. A stray header forces the API-key path.
* Confirm the audience is set to `https://api.noonum.com` exactly. A wrong audience produces tokens the server rejects, which can look like an endless re-auth loop.

### Tools do not appear

* Re-check the JSON is valid (no trailing commas, balanced braces) and fully restart the client.
* Verify the `url` and transport are HTTP and point at `https://api.noonum.ai/v1/mcp`.

### A call hangs or times out

Some tools, notably `submit_strategy`, run server-side pipelines that can take up to ten minutes. If your client cuts the call short, raise its request-level timeout. See [Long-running tasks](/base/agentic/mcp-server#long-running-tasks) for the expected behavior and progress notifications.

### Still stuck

If the problem persists, or the server returns a `5xx` or other server-side error, contact **[hello@noonum.com](mailto:hello@noonum.com)**.

## Next steps

* [Build a strategy](/v2/guides/build-strategy): define an objective and run a strategy end to end.
* Browse the full [MCP tool catalog](/base/agentic/mcp-server#tools), prompts, and long-running tasks.
* Review the [Authentication](/v2/getting-started/authentication) page for API keys and the shared REST auth model.