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 asked	Give it	Why
“What are the odds that…?”	Polymarket Odds Snapshot	Calibrated market probabilities beat model guesses.
“Who is moving money on this market?”	Polymarket Whale Trades Tracker	Live whale tape with wallet aggregation.
“Should I copy this trader?”	Polymarket Wallet P&L Analyzer	Reconstructed P&L with honest coverage flags.
“Which companies are hiring for X?”	ATS Job Board Scraper	Normalized postings + new/removed diffs across 4 ATS systems.
“What businesses just started in my state?”	New Business Filings	Official state filings, formation-mill noise removed.
“Which federal contracts expire soon?”	GovCon Monitor	Recompete 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 →