Public Signal Data
Public Signal Data / Use cases / Data feeds for AI agents

For agent builders

Data feeds for AI agents

An LLM without tools guesses; an agent with the right feeds cites. Every actor here returns flat, schema-stable JSON and is callable from any agent framework through the Apify platform — including one-line MCP setup.

Fastest path

MCP: one config block, six tools

The Apify MCP server exposes actors as typed tools to any MCP client — Claude Desktop, Claude Code, Cursor, ChatGPT connectors, or your own agent runtime. The agent reads each actor's input schema, fills it, runs it, and gets the dataset back. No glue code.

mcp config — all six actors as agent tools
{
  "mcpServers": {
    "public-signal": {
      "url": "https://mcp.apify.com/?actors=splendorous_astrolabe_xs9/polymarket-odds-snapshot,splendorous_astrolabe_xs9/polymarket-whale-trades,splendorous_astrolabe_xs9/polymarket-wallet-pnl,splendorous_astrolabe_xs9/ats-jobs-workday,splendorous_astrolabe_xs9/new-business-filings,splendorous_astrolabe_xs9/govcon-monitor",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}

Trim the actors list to only what your agent needs — fewer tools means better tool selection. Get a token at apify.com → Settings → API & Integrations.

Tool routing

Which feed answers which question

The agent is askedGive itWhy
“What are the odds that…?”Polymarket Odds SnapshotCalibrated market probabilities beat model guesses.
“Who is moving money on this market?”Polymarket Whale Trades TrackerLive whale tape with wallet aggregation.
“Should I copy this trader?”Polymarket Wallet P&L AnalyzerReconstructed P&L with honest coverage flags.
“Which companies are hiring for X?”ATS Job Board ScraperNormalized postings + new/removed diffs across 4 ATS systems.
“What businesses just started in my state?”New Business FilingsOfficial state filings, formation-mill noise removed.
“Which federal contracts expire soon?”GovCon MonitorRecompete radar over USAspending + SAM.gov.

Function calling

OpenAI & Anthropic, without MCP

Every actor is one HTTPS call: run-sync-get-dataset-items takes the input JSON and returns the result rows in the same response. That makes tool definitions trivial.

OpenAI function calling
from openai import OpenAI
import requests, json, os

def run_actor(actor_id, run_input):
    r = requests.post(
        f"https://api.apify.com/v2/acts/{actor_id}/run-sync-get-dataset-items",
        params={"token": os.environ["APIFY_TOKEN"]},
        json=run_input, timeout=300)
    return r.json()

tools = [{
  "type": "function",
  "function": {
    "name": "polymarket_odds",
    "description": "Live Polymarket odds: prices, volume, liquidity "
                   "for markets by category or slug.",
    "parameters": {
      "type": "object",
      "properties": {
        "category": {"type": "string",
          "description": "crypto | politics | sports | economy | tech"},
        "max_markets": {"type": "integer"}
      }
    }
  }
}]

# When the model calls the tool:
# result = run_actor("splendorous_astrolabe_xs9~polymarket-odds-snapshot", args)
Anthropic tool use
import anthropic, requests, os

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    tools=[{
        "name": "whale_trades",
        "description": "Large Polymarket trades above a USD threshold, "
                       "with per-wallet flow summaries.",
        "input_schema": {
            "type": "object",
            "properties": {
                "min_usd": {"type": "number"},
                "lookback_hours": {"type": "number"},
                "market_slug": {"type": "string"}
            }
        }
    }],
    messages=[{"role": "user",
               "content": "Who moved size on Polymarket in the last 6 hours?"}]
)
# On tool_use: POST the input to
# api.apify.com/v2/acts/splendorous_astrolabe_xs9~polymarket-whale-trades\
#   /run-sync-get-dataset-items?token=...
LangChain / LangGraph
from langchain_apify import ApifyActorsTool

whales = ApifyActorsTool("splendorous_astrolabe_xs9/polymarket-whale-trades")
odds = ApifyActorsTool("splendorous_astrolabe_xs9/polymarket-odds-snapshot")

# Add to any LangChain / LangGraph agent's tool list:
agent = create_react_agent(model, tools=[whales, odds])

Why these feeds work in agents

Designed for machine consumers

  • Schema-stable flat rows. No nested blobs to parse; every record is self-contained, so an LLM can reason over raw dataset items.
  • Pay-per-result = bounded cost. An autonomous agent can't accidentally run up a subscription; each call has a predictable price (e.g. $0.12 for a 100-market odds snapshot).
  • Honest flags reduce hallucination. Fields like coverage_capped and agent_is_commercial tell the model what the data does not claim — the difference between citing and confabulating.
  • Deterministic inputs. Simple JSON schemas (a threshold, a state list, a wallet address) that models fill correctly on the first try.

Give your agent its first real feed

Start with the odds snapshot — one config line, and “what are the odds…” questions get grounded in live market prices from then on.

Start with odds →