# DataSignals Lab MCP: 19 Data Tools for AI Agents (`datasignalslab/datasignals-mcp`) Actor

One MCP endpoint, 19 scored data tools for AI agents: hiring signals (who started hiring, who quietly stopped), SEC insider clusters, 13F, 8-K, 13D/G, Form D raises, FDA actions, Congress trades and crypto. Free flagship tool plus 50 free calls a month, then $0.02 per non-empty result after that.

- **URL**: https://apify.com/datasignalslab/datasignals-mcp.md
- **Developed by:** [DataSignals Lab](https://apify.com/datasignalslab) (community)
- **Categories:** AI, MCP servers, Agents
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## DataSignals Lab MCP: Financial and Market Data Tools for AI Agents

**One MCP endpoint, one flagship question: "which signals have the strongest cross-source confluence right now, ranked by conviction?"** Start with the free `confluence_signals` tool for that one-call, ranked, source-linked answer - then drill into the scored, decision-ready feeds behind it. Connect Claude, ChatGPT, Cursor or any MCP client and let the agent pull insider trading, hedge-fund positioning, corporate events, biotech and FDA catalysts, government contracts, Congress trading, research funding, startup fundraising (Form D), crypto momentum and app review sentiment - plus a one-call company dossier and a free ticker/CIK resolver - on demand, with source links.

Free tier, no card: `confluence_signals`, `resolve_company` and `usage` are always free, `hiring_signals` is free up to 25 rows, and you get 50 MCP calls a month plus a free preview of every report. Every other tool costs $0.02 per non-empty result, billed to your own Apify account.

This Model Context Protocol (MCP) server bundles the full DataSignals Lab suite behind a single connection, so an agent can call the right tool autonomously instead of you wiring up a dozen separate APIs.

### Tools

| Tool | What it returns | Source |
|---|---|---|
| `confluence_signals` **(flagship, free)** | The primary entry point: signals ranked by conviction 0-100 by cross-source confluence, each with the confirming source types, a direct filing link and track-record context | DataSignals reasoning layer (`/api/reasoning.json`) |
| `insider_trading_clusters` | Clusters of insider open-market buying, scored 0-100 | SEC EDGAR Form 4 |
| `insider_selling_form144` | Planned insider sales (seller, role, USD value), scored | SEC EDGAR Form 144 |
| `hedge_fund_13f` | Hedge-fund buys, exits and cross-fund consensus | SEC EDGAR 13F |
| `sec_8k_events` | Material 8-K events, classified and materiality-scored | SEC EDGAR 8-K |
| `activist_stakes_13dg` | 5%+ stakes, activist (13D) vs passive (13G), scored | SEC EDGAR 13D/G |
| `biotech_catalysts` | Upcoming trial readouts and phase changes, scored | ClinicalTrials.gov |
| `fda_drug_actions` | FDA approvals and regulatory actions, scored | openFDA Drugs@FDA |
| `government_contracts` | Recent federal contract wins and momentum, scored | USAspending.gov |
| `congress_trading` | House member stock trades, parsed and scored | House Clerk disclosures |
| `nih_research_funding` | NIH grant momentum by organization or topic | NIH RePORTER |
| `startup_funding_form_d` | New capital raises before press coverage, fund noise filtered, scored | SEC EDGAR Form D |
| `crypto_momentum_scanner` | Volume and momentum anomalies, scored | CoinGecko |
| `app_review_intelligence` | App Store aspect sentiment and competitor comparison | Apple App Store |
| `job_openings` | Live job openings and hiring momentum per company, read from the employer's own career site | Company applicant tracking systems (Greenhouse, Lever, Ashby and five more) |
| `company_intelligence` | One scored dossier per company across the sources above | SEC, openFDA, ClinicalTrials.gov, USAspending.gov |
| `resolve_company` | Company name or ticker to SEC CIK, ticker and official name (free) | SEC company registry |
| `usage` | Billed results, estimated cost and remaining budget for this caller (free) | Local MCP usage ledger |

Plus a free `usage` tool that reports billed results, cost and remaining budget under your spend cap.

### How to connect

This Actor runs in Standby mode as a streamable HTTP MCP server at
`https://datasignalslab--datasignals-mcp.apify.actor/mcp`. Point your MCP client there and pass your own Apify API token as a Bearer header. Copy-paste per host:

**Claude Desktop**: add to `claude_desktop_config.json` (Settings -> Developer -> Edit Config):

```json
{
  "mcpServers": {
    "datasignals-lab": {
      "url": "https://datasignalslab--datasignals-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_API_TOKEN>" }
    }
  }
}
```

**Cursor**: add the same block to `~/.cursor/mcp.json` (or Settings -> MCP -> Add new server).

**VS Code**: add to `.vscode/mcp.json` in your workspace (or run "MCP: Add Server" from the Command Palette). VS Code uses a `servers` block with an explicit transport type:

```json
{
  "servers": {
    "datasignals-lab": {
      "type": "http",
      "url": "https://datasignalslab--datasignals-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_API_TOKEN>" }
    }
  }
}
```

**ChatGPT**: reach it through Apify's hosted gateway: add a connector / custom MCP server pointing at `https://mcp.apify.com` and enable the Actor `datasignalslab/datasignals-mcp` (the gateway handles the Apify token). Live Actor listing: https://apify.com/datasignalslab/datasignals-mcp

**Any other MCP client** (Windsurf, Cline, LibreChat, your own agent): point it at the streamable-HTTP endpoint `https://datasignalslab--datasignals-mcp.apify.actor/mcp` and send your own Apify API token in an `Authorization: Bearer <YOUR_APIFY_API_TOKEN>` header. Clients that read a `mcpServers` object take the exact block shown for Claude Desktop above.

### Example questions

Three questions that show the flagship tool, `confluence_signals` (one free call, the complete ranked answer):

1. "Which signals have the strongest cross-source confluence right now, ranked by conviction?"
2. "What are the highest-conviction signals across all your sources this week?"
3. "Is any stock being flagged by more than one independent source at the same time?"

For a broad question about one named company, `company_intelligence` returns a single scored dossier ("What's going on with TSLA - any red flags?"). Or hit a single feed directly: "Which insiders are buying clusters this week?", "What did House members trade in NVDA?", or "What did Berkshire add or exit last quarter?" - the agent picks the matching tool automatically.

### Pricing

Each tool runs the underlying DataSignals Lab Actor, which is pay-per-event (typically $0.02 per analyzed company, fund, scan or query). There is no separate subscription and no extra markup for using the bundle.

#### Reports and subscriptions

Scored signals from SEC, FDA, Congress and other official filings. The daily output is hashed and anchored, so past signals cannot be edited. Agents call it over MCP. [See the track record](https://datasignalslab.com/proof.html)

Every score in every report lists the terms it was built from, so you can check the number instead of trusting it.

This Actor also powers the [DataSignals Lab](https://datasignalslab.com) reports. All prices are listed on the [pricing page](https://datasignalslab.com/pricing.html):

- **Free.** Report previews, a weekly signal digest and 50 free MCP calls per month for AI agents.
- **Snapshot, $19 one time.** The current edition of one report plus 30 days of updates.
- **DataSignals Pro, $29 per month or $290 per year.** All three reports refreshed monthly, MCP access for AI agents (2000 calls per month fair use), email alerts. Cancel anytime.

### Usage, billing and spend caps

- **Charge-on-success.** A tool call is only billed when it succeeds *and* returns a non-empty result. A failed call or a valid-but-empty result (e.g. no insider clusters this week) costs nothing.
- **Every result has a `summary` field.** Alongside the structured JSON (`items`, `count`, `sections`, ...), each tool returns a short plain-text `summary` line, so a text-only agent that can't render structured/interactive content still gets a readable answer.
- **Spend caps.** Pass `spend_cap_usd` (and optionally a stable `caller_id`) in the MCP call's `_meta` to cap what a single caller can spend through this server. Once a caller's tracked spend reaches the cap, further calls are refused with a clear error and are not charged.
- **`usage` tool.** Call `usage` (no required fields) anytime to see billed results, estimated cost so far, and remaining budget against a spend cap.
- **`resolve_company` is always free.** It's a local SEC ticker/CIK lookup and never runs a downstream Actor.

### Optional: x402 payment rail (off by default)

This server can optionally accept the emerging [x402](https://www.x402.org/) "pay per call" HTTP protocol as an alternative to an Apify API token. It ships **disabled** and has no effect unless the owner turns it on:

- `DATASIGNALS_X402_ENABLED=true` - turns the rail on (default: off).
- `DATASIGNALS_X402_PAY_TO=<address>` - the receiving address; without this the rail stays enabled-but-inert so a half-configured flag can never start blocking callers.
- `DATASIGNALS_X402_NETWORK=<network>` - optional, defaults to `base`.

This is scaffolding only (see `my_actor/x402.py`): it emits a 402-shaped challenge but does not implement real payment verification, settlement or replay protection. Wiring up an actual facilitator is separate, owner-reviewed work.

### Data and compliance

All tools use official, public, non-personal sources (SEC EDGAR, openFDA, ClinicalTrials.gov, USAspending.gov, the House Clerk, NIH RePORTER, CoinGecko and the Apple App Store reviews feed). Output is data for research and monitoring, not investment advice. Historical patterns do not guarantee future results.

# Actor input Schema

## Actor input object example

```json
{}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datasignalslab/datasignals-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("datasignalslab/datasignals-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call datasignalslab/datasignals-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datasignalslab/datasignals-mcp"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kaYxXwECtYxCuAqch/builds/QINyI3LrUvd85fHKj/openapi.json