# Reference Source — verified reference data lookup & MCP server (`referencesource/referencesource-lookup`) Actor

Look up regulatory thresholds, certification registers, version-compatibility and licensing rules. Every record carries the source URL and a verbatim quote from that page, so the value can be checked. Also runs as an MCP server in Standby mode.

- **URL**: https://apify.com/referencesource/referencesource-lookup.md
- **Developed by:** [Reference Source](https://apify.com/referencesource) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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/actors/running/actors-in-store.md#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

## Reference Source — verified reference data lookup & MCP server

Look up a regulatory threshold, a certification status, a jurisdictional rule or
a version-compatibility fact, and get back the value **plus the URL it came from
and a verbatim quote from that page**. Every record. No exceptions.

181 datasets, 73,109 records (2026-08-19), all published at
[referencesource.org](https://referencesource.org/).

### What it does

Four operations:

| Tool | Answers |
| --- | --- |
| `list_datasets` | What data is here, how many records, when each was last verified |
| `search_records` | Find records in one dataset by county, state, chemical, certificate number, product name — any substring |
| `get_record` | Fetch one record by id |
| `verify_quote` | Check a value you already hold against the published record and its source quote |

`verify_quote` is the one that is hard to get elsewhere. Give it a value and it
reports whether it matches the stored value, whether it appears in the source
quote, and returns the source URL either way — so a number you got from
somewhere else can be traced to a page that states it, or shown not to be there.

### Two ways to use it

**As an integration** — run the Actor with an input, read the dataset. One row
per record, each row carrying `source`, `source_quote`, `last_verified` and
`stale_after`. Works anywhere Apify does: Make, n8n, Gumloop, the API, a
schedule.

```json
{
  "tool": "search_records",
  "dataset_slug": "conforming-loan-limits",
  "query": "Autauga"
}
```

```json
{
  "tool": "verify_quote",
  "dataset_slug": "conforming-loan-limits",
  "record_id": "01001",
  "claimed_value": "$806,500"
}
```

→ `differs`, naming the value the record actually holds and quoting the FHFA
row it was read from.

**As an MCP server** — this Actor runs in Standby mode, so it is a
streamable-HTTP MCP endpoint your agent can call directly:

```
https://<your-username>--referencesource-lookup.apify.actor/mcp
```

All four tools are read-only (`readOnlyHint: true`), touch nothing outside the
published catalogue, and never fetch an arbitrary URL.

### What's in it

Regulatory thresholds and effective dates, certification and validation
registers, end-of-support and deprecation dates, licensing and eligibility
rules, state-by-state legal variation, compatibility and fitment tables.
Call `list_datasets` for the current list — it changes as datasets are added
and re-verified.

### Pricing

Pay per event: one charge per tool call, plus one per record actually
delivered. A search that matches nothing costs the call and nothing more, and a
call that fails is not charged at all.

### Provenance

Every value is published with the page it was read from and a verbatim quote
from that page, and the extraction is checked by asserting the value appears
inside its own quote. Datasets carry a `last_verified` and a `stale_after`
date; anything found wrong is fixed or withdrawn. If the source does not state
it, there is no row — this data contains no estimates, no interpolation and no
model-generated values.

Method: <https://referencesource.org/method/>
Connect: <https://referencesource.org/connect/>

# Actor input Schema

## `tool` (type: `string`):

list\_datasets: what data exists. search\_records: find records in one dataset. get\_record: fetch one record by id. verify\_quote: check a value you already hold against the published record and its source quote.

## `dataset_slug` (type: `string`):

The dataset's slug, as returned by list\_datasets — for example "conforming-loan-limits" or "graduated-driver-licensing". Not needed for list\_datasets.

## `query` (type: `string`):

Substring matched case-insensitively across every field of every record: a county, a state, a chemical, a certificate number, a product name. Used by search\_records.

## `record_id` (type: `string`):

The record's id — it appears in search results and at the end of each record's URL. Required by get\_record; optional for verify\_quote, which searches the dataset without it.

## `claimed_value` (type: `string`):

The value exactly as claimed, e.g. "$832,750". verify\_quote reports whether it matches the stored value, whether it appears in the source quote, and returns the source URL either way.

## `field` (type: `string`):

Optional. Restrict verify\_quote to one field, e.g. "limit\_1\_unit". Without it, every stored field is checked.

## `arguments` (type: `object`):

Passed straight through to the tool, overriding the fields above. For callers driving this from code.

## Actor input object example

```json
{
  "tool": "search_records",
  "dataset_slug": "conforming-loan-limits",
  "query": "Autauga"
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record delivered. Every row carries dataset\_slug, the record id, the source URL it was read from, the verbatim source\_quote that states the value, and the last\_verified date.

## `reply` (type: `string`):

The complete JSON reply from the tool call, including dataset metadata, coverage counts, and — for verify\_quote — the verdict.

# 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 = {
    "dataset_slug": "conforming-loan-limits",
    "query": "Autauga"
};

// Run the Actor and wait for it to finish
const run = await client.actor("referencesource/referencesource-lookup").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 = {
    "dataset_slug": "conforming-loan-limits",
    "query": "Autauga",
}

# Run the Actor and wait for it to finish
run = client.actor("referencesource/referencesource-lookup").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 '{
  "dataset_slug": "conforming-loan-limits",
  "query": "Autauga"
}' |
apify call referencesource/referencesource-lookup --silent --output-dataset

```

## MCP server setup

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

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/Ny4YaemKtEHt7dcXm/builds/SJjBi6dRwRTcjuZb6/openapi.json