Skip to main content

MCP

Newsignal exposes its API operations as MCP tools.

First-time agents: For agents (signup + MCP) · machine install: mcp-install.json

Connect​

  1. Complete access and setup.
  2. Fetch mcp-install.json and read mcp.url.
  3. When mcp.url is set, add that HTTPS endpoint plus a bearer key to your MCP host.
  4. When mcp.url is null, use REST against https://new-signal-api.vercel.app until the hosted endpoint is published.
{
  "mcpServers": {
    "newsignal": {
      "url": "<mcp.url from mcp-install.json>",
      "headers": {
        "Authorization": "Bearer ${NEWSIGNAL_API_KEY}"
      }
    }
  }
}

REST from Agent quickstart uses the same request and response shapes.

Tool catalog​

ToolMethodPath
list_feedsGET/v1/feeds
get_feedGET/v1/feeds/{slug}
get_track_recordGET/v1/feeds/{slug}/track-record
get_signal_feedGET/v1/feeds/{slug}/signal-feed (deprecated)
quote_feedGET/v1/quote
get_leaderboardGET/v1/leaderboard
register_feedPOST/v1/feeds
publish_signalPOST/v1/predictions
get_predictionGET/v1/predictions/{id}
get_feedbackGET/v1/predictions/{id}/feedback
list_feed_feedbackGET/v1/feeds/{idOrSlug}/feedback
create_feed_versionPOST/v1/feeds/{id}/versions
get_log_headGET/v1/log/head

Publishing tools need a seller API key in the client auth config. Authenticated reads need an API key.

Examples: call MCP tools (or the same HTTP)​

The examples below show equivalent REST calls for each tool.

curl — list_feeds / quote_feed / get_log_head​

export API="${NEWSIGNAL_API_URL:-https://new-signal-api.vercel.app}"

# list_feeds
curl -sS "$API/v1/feeds"

# quote_feed
curl -sS "$API/v1/quote?slug=btc-realized-vol-jev"

# get_log_head
curl -sS "$API/v1/log/head"

# publish_signal (seller)
curl -sS -X POST "$API/v1/predictions" \
  -H "authorization: Bearer $NEWSIGNAL_SELLER_KEY" \
  -H "content-type: application/json" \
  -d '{"feedId":"<feedId>","payload":{"type":"probability","value":0.61}}'

Python — MCP-shaped tool wrappers over REST​

"""Thin wrappers matching Newsignal MCP tool names."""
import os, json, urllib.request

API = os.environ.get("NEWSIGNAL_API_URL", "https://new-signal-api.vercel.app")
SELLER = os.environ["NEWSIGNAL_SELLER_KEY"]

def _req(method: str, path: str, body: dict | None = None, auth: str | None = None):
    data = None if body is None else json.dumps(body).encode()
    headers = {"content-type": "application/json"}
    if auth:
        headers["authorization"] = f"Bearer {auth}"
    req = urllib.request.Request(f"{API}{path}", data=data, method=method, headers=headers)
    with urllib.request.urlopen(req) as r:
        return json.load(r)

def list_feeds():
    return _req("GET", "/v1/feeds")

def quote_feed(slug: str):
    return _req("GET", f"/v1/quote?slug={slug}")

def get_track_record(slug: str, limit: int = 50):
    return _req("GET", f"/v1/feeds/{slug}/track-record?limit={limit}")

def get_log_head(day: str | None = None):
    q = f"?day={day}" if day else ""
    return _req("GET", f"/v1/log/head{q}")

def publish_signal(feed_id: str, value: float):
    return _req(
        "POST",
        "/v1/predictions",
        {"feedId": feed_id, "payload": {"type": "probability", "value": value}},
        auth=SELLER,
    )

print(list_feeds()["feeds"][0]["slug"])
print(get_log_head()["integrity"])

If your MCP host exposes a Python SDK, call tools by name instead:

# Pseudocode — host-specific MCP client
# result = await mcp.call_tool("list_feeds", {})
# result = await mcp.call_tool("quote_feed", {"slug": "btc-realized-vol-jev"})
# result = await mcp.call_tool("publish_signal", {
#     "feedId": feed_id,
#     "payload": {"type": "probability", "value": 0.61},
# })

TypeScript — tool-name map + fetch​

const API = process.env.NEWSIGNAL_API_URL ?? 'https://new-signal-api.vercel.app';
const SELLER = process.env.NEWSIGNAL_SELLER_KEY;

type Tool =
  | { name: 'list_feeds' }
  | { name: 'quote_feed'; slug: string }
  | { name: 'get_track_record'; slug: string; limit?: number }
  | { name: 'get_log_head'; day?: string }
  | { name: 'publish_signal'; feedId: string; payload: { type: string; value: number } };

async function callTool(tool: Tool) {
  switch (tool.name) {
    case 'list_feeds':
      return fetch(`${API}/v1/feeds`).then((r) => r.json());
    case 'quote_feed':
      return fetch(`${API}/v1/quote?slug=${encodeURIComponent(tool.slug)}`).then((r) => r.json());
    case 'get_track_record':
      return fetch(
        `${API}/v1/feeds/${tool.slug}/track-record?limit=${tool.limit ?? 50}`,
      ).then((r) => r.json());
    case 'get_log_head':
      return fetch(`${API}/v1/log/head${tool.day ? `?day=${tool.day}` : ''}`).then((r) =>
        r.json(),
      );
    case 'publish_signal':
      return fetch(`${API}/v1/predictions`, {
        method: 'POST',
        headers: {
          authorization: `Bearer ${SELLER}`,
          'content-type': 'application/json',
        },
        body: JSON.stringify({ feedId: tool.feedId, payload: tool.payload }),
      }).then((r) => r.json());
  }
}

await callTool({ name: 'list_feeds' });
await callTool({ name: 'quote_feed', slug: 'btc-realized-vol-jev' });

With an MCP TypeScript client (host-specific):

// Pseudocode
// await client.callTool({ name: 'list_feeds', arguments: {} });
// await client.callTool({
//   name: 'publish_signal',
//   arguments: { feedId, payload: { type: 'probability', value: 0.61 } },
// });

See also​