# citature MCP Server: cited federal money data as agent tools (`citature/citature-mcp`) Actor

A Model Context Protocol server exposing citature's cited federal campaign-finance and contract-award answers as tools. Runs in Standby mode over Streamable HTTP; every tool returns a full receipt with the exact source, retrieval time, coverage caveats, and guardrails.

- **URL**: https://apify.com/citature/citature-mcp.md
- **Developed by:** [citature](https://apify.com/citature) (community)
- **Categories:** AI, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 tool calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## citature MCP Server — cited federal money data as agent tools

A **Model Context Protocol** server that gives an AI agent direct, tool-shaped
access to citature's cited federal data: campaign contributions, contract awards,
follow-the-money flows, and committee/candidate lookup. Every tool returns a
**receipt** — the exact public source URL, when it was retrieved, coverage
caveats, match provenance, and guardrails — so an agent can verify every number
against the primary federal record.

Runs in Apify **Standby** mode: the server stays warm and answers over
**Streamable HTTP** at `/mcp`, so tool calls are fast and the underlying data
connection is established once, not per request.

Keywords: MCP server, Model Context Protocol, AI agent tools, campaign finance
API, federal spending API, FEC data, USAspending, government contracts, follow the
money, cited data, agent-ready, structured tool output.

### Tools

Each tool takes a small typed input and returns both human-readable text (the
answer) and `structuredContent` (the full receipt).

Fourteen tools, on two pricing tiers — the eleven standard tools and the three
**govcon** tools (marked below), which meter higher for parity with the standalone
govcon actors (see [Pricing](#pricing)).

| Tool | Input | Returns | Tier |
|---|---|---|---|
| `contributions_by_state` | `cycle`, `limit?` | contribution totals by contributor state | standard |
| `contributions_by_committee_type` | `cycle`, `limit?` | contribution totals by committee type | standard |
| `awards_by_agency` | `fiscal_year`, `limit?` | award totals by awarding agency | standard |
| `awards_by_state` | `fiscal_year`, `limit?` | award totals by place-of-performance state | standard |
| `awards_by_recipient` | `fiscal_year`, `limit?` | award totals by recipient (UEI) | standard |
| `follow_the_money` | `committee_id`, `cycle?`, `limit?` | contribution inflows by contributor state | standard |
| `committee_lookup` | `committee_id` | one committee (or null) | standard |
| `candidate_lookup` | `candidate_id` | one candidate (or null) | standard |
| `committee_search` | `name_prefix`, `limit?` | committees by name prefix | standard |
| `candidate_search` | `name_prefix`, `limit?` | candidates by name prefix | standard |
| `recompetes_expiring` | `expiring_from`, `expiring_to`, `naics?`, `agency?`, `limit?` | federal contracts expiring in a `YYYY-MM` window, soonest first, each with the incumbent (by UEI) and its obligation | **govcon** |
| `incumbent_history` | `uei?` or `recipient?` (one required), `agency?`, `naics?`, `limit?` | a contractor's contract lineage per agency and NAICS: count, total obligated, fiscal-year span, latest period-of-performance end | **govcon** |
| `agency_buying` | `agency?`, `naics?`, `fiscal_year?`, `limit?` | federal obligations, contract counts, and distinct-contractor counts by awarding agency, NAICS, and fiscal year | **govcon** |
| `opportunity_search` | `naics?`, `agency?`, `posted_from?`, `posted_to?`, `active?`, `limit?` | open and forecasted procurement opportunities across SAM.gov and Grants.gov, newest first (no standalone actor) | standard |

Every tool description embeds the guardrail caveats below, so an agent reads them
before it calls.

### Connecting

Point any MCP client at the Standby endpoint (Streamable HTTP transport):

```
https://<your-actor-standby-url>/mcp
```

A tool call returns a receipt as `structuredContent`. For example, calling
`awards_by_agency` with `{ "fiscal_year": 2024, "limit": 2 }`:

```json
{
  "answer": [
    {
      "fiscal_year": 2024,
      "agency_entity_id": "agcy_fbc1…",
      "agency_name": "Department of Defense",
      "total_cents": 5647517724781,
      "award_count": 113
    }
  ],
  "citations": [
    {
      "source": "usaspending",
      "source_label": "USASpending.gov",
      "query_url": "https://api.usaspending.gov/api/v2/search/spending_by_award/?page=1",
      "retrieved_at": "2026-01-02T00:00:00.000Z",
      "as_of": null,
      "cache": "cached",
      "record_id": null
    }
  ],
  "coverage": ["Coverage reflects records currently in citature's dataset, not the full upstream history."],
  "guardrails": [
    "Research over public-domain federal records — not legal, financial, or eligibility advice.",
    "citature reports what the record says. It never renders a compliance verdict, a screening pass/fail, or a recommendation.",
    "Entity-level records only (committees, candidates, recipients, agencies, contracts). No individual-person data."
  ],
  "matches": [
    {
      "match_method": "exact",
      "match_confidence": 1,
      "left_key": "usaspending.awarding_agency",
      "right_key": "citature.entity_agency.agency_name",
      "note": "agency resolved to a citature entity on the toptier awarding-agency name"
    }
  ],
  "schema_version": "0.1.0"
}
```

Money is always integer **cents**. `retrieved_at` is when citature fetched the
record; a source's own as-of date, when it publishes one, is a separate field.

### Guardrails

- Research over public-domain federal records — **not** legal, financial, or
  eligibility advice.
- citature reports what the record says. It never renders a compliance verdict, a
  screening pass/fail, or a recommendation.
- Entity-level records only. No individual-person data is ever returned.

### Pricing

Pay per tool call, on two tiers. The eleven **standard** tools meter on the
`tool-call` event; the three **govcon** tools — `recompetes_expiring`,
`incumbent_history`, and `agency_buying` — meter on the higher `tool-call-govcon`
event, so this MCP surface never undercuts the standalone govcon actors. A call
bills at the rate of the tool it invokes. The per-event prices are set in the Apify
Console, which is the authoritative record of what a call is billed.

You are charged only when a tool returns an answer; a rejected (invalid input) or
failed call is never billed.

# Actor input Schema

## Actor input object example

```json
{}
```

# Actor output Schema

## `mcp` (type: `string`):

No description

# 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("citature/citature-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("citature/citature-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 citature/citature-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=citature/citature-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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