So I tried something simpler: hand the whole question to a research agent and get an answer back. That's what NeuroAPI does. It's Neurobro's research agent behind a single endpoint, and you can ask it about crypto, stocks, forex and commodities. It's also exposed as a remote MCP server with exactly one tool, so your editor's AI can call it directly.

This post walks through both paths: MCP first, because it takes about two minutes, then the REST API for when you want it inside your own app.

What you need

• A NeuroAPI key. You create it in the dashboard under API Keys. The full secret is shown once, so put it somewhere safe right away. Keys look like neuro_....
• An environment variable holding it:

export NEUROAPI_KEY="neuro_..."

Every snippet below reads the key from that variable. Don't hard-code it and don't commit it.

Quick sanity check before anything else. GET /health is an authenticated call that confirms the key and the connection:

curl -s https://api.neurobro.ai/api/v1/health \
  -H "X-API-Key: $NEUROAPI_KEY" | jq

The docs show a response like this (your version number may differ):

{
  "status": "healthy",
  "service": "neuroapi",
  "version": "0.1.13",
  "authenticated": true,
  "key_prefix": "neuro_a1b2c3d4",
  "timestamp": "2026-05-08T12:34:56.789Z"
}

Part 1: MCP in your editor

The MCP server is remote and runs over Streamable HTTP, so there's nothing to install or host. You point your client at one URL:

https://api.neurobro.ai/api/v1/mcp

Authentication uses the same X-API-Key header as the REST API. Never put the key in the URL; the server rejects keys in the query string with a 400.

Claude Code

Add a .mcp.json at your repo root. Claude Code expands ${VAR} from your environment:

{
  "mcpServers": {
    "neuroapi": {
      "type": "http",
      "url": "https://api.neurobro.ai/api/v1/mcp",
      "headers": {
        "X-API-Key": "${NEUROAPI_KEY}"
      }
    }
  }
}

Cursor

Put this in ~/.cursor/mcp.json (global) or .cursor/mcp.json (per project). Cursor uses ${env:VAR}:

{
  "mcpServers": {
    "neuroapi": {
      "url": "https://api.neurobro.ai/api/v1/mcp",
      "headers": {
        "X-API-Key": "${env:NEUROAPI_KEY}"
      }
    }
  }
}

VS Code

Add .vscode/mcp.json to your workspace. The "type": "http" line matters: without it, VS Code treats the entry as a local command and tries to execute the URL. The inputs block prompts for the key once and keeps it in VS Code's secret storage:

{
  "servers": {
    "neuroapi": {
      "type": "http",
      "url": "https://api.neurobro.ai/api/v1/mcp",
      "headers": {
        "X-API-Key": "${input:neuroapi-key}"
      }
    }
  },
  "inputs": [
    {
      "id": "neuroapi-key",
      "type": "promptString",
      "description": "NeuroAPI API key",
      "password": true
    }
  ]
}

Clients that only speak stdio, like Claude Desktop, can connect through the mcp-remote bridge. The client setup page has the exact config, including a gotcha about keeping the header value as a single token.

Check that it worked

Your client should list exactly one tool: ask_neuroapi. Then ask something like "What's the macro setup for the euro this week?" and watch it call the tool.

The tool takes the same inputs as the REST endpoint:

One thing to know: MCP tool calls aren't streamed. You get one complete answer. If you want tokens as they arrive, use the REST endpoint with streaming.

Part 2: The REST API

Everything goes through one endpoint: POST https://api.neurobro.ai/api/v1/agent/ask.

A simple question

import os, httpx

res = httpx.post(
    "https://api.neurobro.ai/api/v1/agent/ask",
    headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
    json={
        "prompt": "Summarise the latest macroeconomic outlook for the eurozone in one sentence."
    },
    timeout=60,
)
data = res.json()
print(data["answer"])

The response has answer, request_id and a usage block. Here's the sample from the quickstart, trimmed (the answer text is shortened in the docs too):

{
  "answer": "The European Central Bank held rates steady ...",
  "request_id": "8b3a2f0e-1d7e-4c6b-9b2a-f5e23a1c9d44",
  "usage": {
    "prompt_tokens": 124,
    "completion_tokens": 256
  }
}

Keep request_id around. It's also sent back as the X-Request-Id header, and it's the thing support will ask for if something goes wrong.

Follow-up questions

The API is stateless, so your code owns the conversation. Send earlier turns in message_history with roles user and assistant:

import os, httpx

def ask(prompt: str, history: list[dict]) -> dict:
    res = httpx.post(
        "https://api.neurobro.ai/api/v1/agent/ask",
        headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
        json={"prompt": prompt, "message_history": history},
        timeout=60,
    )
    return res.json()

history = [
    {"role": "user", "content": "Compare AAPL and MSFT on FY2024 earnings growth."},
    {"role": "assistant", "content": "Both delivered double-digit YoY revenue growth, with..."},
]
print(ask("How did their gross margins evolve over the same period?", history)["answer"])

Instructions go in system_prompt, not in a system turn; those are accepted but ignored.

Shaping the answer with a system prompt

system_prompt layers on top of the agent's built-in instructions. It can't override its persona or guardrails, but it's the cleanest way to make answers fit your UI:

import os, httpx

res = httpx.post(
    "https://api.neurobro.ai/api/v1/agent/ask",
    headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
    json={
        "prompt": "How is the EUR/USD pair looking this week?",
        "system_prompt": (
            "You are a concise FX strategist. Lead with a one-line bias "
            "(long/short/neutral), then three supporting bullets. Flag any "
            "figure you are not confident about."
        ),
    },
    timeout=60,
)
print(res.json()["answer"])

Structured output

This is my favourite part. Pass output_schema (a JSON Schema with an object root) and the result comes back in output, with answer set to null. No parsing free text.

import os, httpx

schema = {
    "type": "object",
    "properties": {
        "stance": {"type": "string", "enum": ["bullish", "bearish", "neutral"]},
        "conviction": {"type": "number", "description": "0-1 confidence"},
        "support": {"type": "number"},
        "resistance": {"type": "number"},
        "summary": {"type": "string"},
    },
    "required": ["stance", "conviction", "support", "resistance", "summary"],
    "additionalProperties": False,
}

res = httpx.post(
    "https://api.neurobro.ai/api/v1/agent/ask",
    headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
    json={
        "prompt": "Give me a structured read on Bitcoin right now.",
        "output_schema": schema,
    },
    timeout=120,
)
output = res.json()["output"]
print(output["stance"], output["conviction"])

The docs' example of what lands in output:

{
  "stance": "bullish",
  "conviction": 0.62,
  "support": 58000,
  "resistance": 72000,
  "summary": "Holding above the 50-day average with improving spot demand."
}

Two notes from the docs. Structured output is non-streaming only. And because the agent fetches live data before filling your schema, a call usually takes 10 to 60 seconds, so set your timeout to at least 120.

Streaming

For chat UIs, send "stream": true and read Server-Sent Events. Each data: line is a JSON object, text arrives in data.answer.chunk.content, and the stream ends with data: [DONE]:

import json, os, httpx

with httpx.stream(
    "POST",
    "https://api.neurobro.ai/api/v1/agent/ask",
    headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
    json={
        "prompt": "Walk me through a top-down technical read on NVDA right now.",
        "stream": True,
    },
    timeout=None,
) as res:
    for line in res.iter_lines():
        if not line.startswith("data: "):
            continue
        payload = line[len("data: "):]
        if payload == "[DONE]":
            break
        event = json.loads(payload)
        if event["type"] == "error":
            raise RuntimeError(event["message"])
        answer = event["data"]["answer"]
        if answer:
            print(answer["chunk"]["content"], end="", flush=True)

Only [DONE] means the answer is complete. If the run fails, the last event is an error and there's no [DONE].

Gold vs. NVDA vs. Bitcoin, side by side

Here's the one that sold me. A question I actually ask myself: which of these three looks best right now? Instead of reading three different dashboards, I ask about each one with the same schema and line the answers up.

import os, httpx

ASSETS = ["gold", "NVDA", "Bitcoin"]

schema = {
    "type": "object",
    "properties": {
        "stance": {"type": "string", "enum": ["bullish", "bearish", "neutral"]},
        "conviction": {"type": "number", "description": "0-1 confidence"},
        "support": {"type": "number"},
        "resistance": {"type": "number"},
        "summary": {"type": "string"},
    },
    "required": ["stance", "conviction", "support", "resistance", "summary"],
    "additionalProperties": False,
}

def read(asset: str) -> dict:
    res = httpx.post(
        "https://api.neurobro.ai/api/v1/agent/ask",
        headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
        json={
            "prompt": f"Give me a structured read on {asset} right now.",
            "output_schema": schema,
        },
        timeout=120,
    )
    res.raise_for_status()
    return res.json()["output"]

reads = {asset: read(asset) for asset in ASSETS}

for asset, r in sorted(reads.items(), key=lambda kv: kv[1]["conviction"], reverse=True):
    print(f"{asset:<8} {r['stance']:<8} {r['conviction']:.2f}  {r['summary']}")

Because every answer has the same shape, the "comparison" is just a sort. You can push the same dicts into a table, a chart or a Slack message without touching a parser. I kept one question per asset on purpose: each call stays focused, and if one fails you still get the other two.

Putting it together: a morning watchlist brief

Same idea, wider net. This one runs on a cron before I open any charts. It asks for a structured read on a few markets and writes the results to a JSON file you can feed into a dashboard or a chat message. The request shape is straight from the docs; the watchlist and file handling are mine.

import json, os, httpx

WATCHLIST = ["Bitcoin", "NVDA", "EUR/USD", "gold"]

schema = {
    "type": "object",
    "properties": {
        "stance": {"type": "string", "enum": ["bullish", "bearish", "neutral"]},
        "conviction": {"type": "number", "description": "0-1 confidence"},
        "summary": {"type": "string"},
    },
    "required": ["stance", "conviction", "summary"],
    "additionalProperties": False,
}

def read(market: str) -> dict:
    res = httpx.post(
        "https://api.neurobro.ai/api/v1/agent/ask",
        headers={"X-API-Key": os.environ["NEUROAPI_KEY"]},
        json={
            "prompt": f"Give me a structured read on {market} right now.",
            "output_schema": schema,
        },
        timeout=120,
    )
    res.raise_for_status()
    body = res.json()
    return {"market": market, "request_id": body["request_id"], **body["output"]}

brief = [read(m) for m in WATCHLIST]

with open("brief.json", "w") as f:
    json.dump(brief, f, indent=2)

A few practical things the docs call out that are worth building in from day one:

• Retry only on 429 and 503, and honour Retry-After. Don't retry blindly on 500, because /agent/ask isn't idempotent. The examples page has a backoff helper.
• Log request_id for every call.
• Keep the key in an env var or secret manager, and revoke it from the dashboard if it leaks.

And the obvious one: treat the answers as research input for your own decisions, not financial advice.

Links

• Docs: neuroapi.neurobro.ai/docs
• MCP overview: neuroapi.neurobro.ai/docs/mcp
• Client setup: neuroapi.neurobro.ai/docs/mcp/clients
• Examples: neuroapi.neurobro.ai/docs/best-practices/examples
• Neurobro on X: @0xNeurobro

That's the whole setup. If you build something with it, drop a link in the comments. I'd genuinely like to see it.