# US IRS Exempt Organization Master File - Per EIN (`nexgensignal/us-exempt-organization-master-records`) Actor

US IRS Exempt Organizations Business Master File (6 regional extracts) as clean per-EIN records - name, address, subsection, classification, ruling, status and asset/income bands. 1.96M orgs; in-care-of line dropped. Public domain. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/us-exempt-organization-master-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 exempt organization records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## US IRS Exempt Organization Master File - Per EIN

Every U.S. tax-exempt organisation on the **IRS Exempt Organizations Business Master File** as one clean, flat
record - EIN, name, address, subsection, classification, ruling date, exemption status and the asset/income
code bands. Six regional extracts, one dataset. The in-care-of person line is dropped.

### What one record represents

The source is the **IRS Exempt Organizations Business Master File (EO BMF)**, the federal registry of
tax-exempt organisations, published as six regional CSV extracts. Each record is **one organisation (EIN)**:
its EIN, name, address, group exemption number, IRC subsection, affiliation, classification, ruling date,
deductibility, foundation type, exemption status, latest tax period, and the asset and income code bands.

### Coverage and volume

The six extracts together hold **1,962,246** organisations - measured live at build time.

**Sol's Wave-4 index put this door at 1,962,246 EXACT; measured live at build time the six extracts sum to
1,962,246 organisations - matching the index.**

The Actor downloads the six regional CSVs in turn and delivers each organisation, stopping as soon as your
**Maximum records** cap is met.

### Licence and attribution

The EO BMF is a U.S. Government work in the public domain. The full notice travels on every record:

> U.S. Internal Revenue Service, Exempt Organizations Business Master File Extract. U.S. Government work in the public domain (17 U.S.C. 105) - no copyright.

### Person-data policy

The EO BMF carries an in-care-of line (`ICO`) that is frequently a natural person (the organisation's contact
or officer). This Actor **structurally drops ICO** - it is never mapped or emitted - and a per-record assertion
rejects any in-care-of/sort-name/person field (verified with a planted-field test). Everything delivered is an
organisation attribute: the name is the organisation, and the address is its registered address. No
natural-person data is processed.

### Distinctness from the ProPublica 990 cells

About **60%** of this roster overlaps with the organisations in the fleet's ProPublica IRS-990 cells, but the
field grain is distinct: this cell is the IRS **registry status and classification** view - subsection, NTEE
(via classification), ruling date, exemption status and asset/income bands - while the 990 cells carry the
**filing financials** (revenue, expenses, line-items). Join on the EIN to combine registry status with filing
detail; the two do not duplicate each other.

### Interpretation caveat

One record per exempt organisation (EIN) across the six regional IRS EO BMF extracts: name, address, subsection, classification, ruling date, deductibility, foundation type, exemption status, tax period and the asset/income code bands. The in-care-of person line (ICO) is structurally dropped and never emitted.

Values are reproduced verbatim from the extracts; the Actor never rewrites a field. Codes (subsection,
classification, status, asset/income bands) are the IRS's own code values, kept as strings; the IRS publishes
the code tables that decode them.

### Provenance and compliance

Every run reads the door host's `robots.txt` at runtime; the gate result (URL, status, byte length and, where a
policy is served, its SHA-256) is written to the run's `RUN_RECEIPT`. Where the host serves no robots.txt, the
gate records that fact (flagged) and proceeds on the licence, which expressly grants re-use. The endpoint is
keyless. The Actor never bypasses a block or fetches through a mirror.

### Data quality and freshness

Boolean columns are delivered as real booleans and numeric columns as real numbers. Delivery is keyed on a
stable id, so the dataset is safe to diff, deduplicate or upsert. Every run re-reads the live door, so the data
is as fresh as the source publishes, and each record's `observed_at` stamp dates the snapshot. The run's
`RUN_RECEIPT` records the source URL and how many records were delivered and charged, and confirms
`charge_equals_delivered`.

### Billing and delivery

Pricing is per record: you are billed only for records the Actor actually delivers, with the charge raised
after each record is pushed (push-then-charge), so a failed or empty run costs nothing. The **Maximum records**
cap bounds every run, so you control spend precisely - sample cheaply, then raise it. Because delivery is keyed
on a stable id, re-running and upserting keeps a downstream table current without re-paying for rows you already
hold; only new and changed records add cost, and every receipt reconciles delivered against charged.

### Schema, typing and joins

Every record is a flat object with a fixed, typed schema: strings stay strings, numbers are parsed to real
numbers, and booleans to real booleans, so the data loads into a warehouse or a dataframe without a cleaning
pass. The `record_id` is a stable composite key, which means the dataset is safe to diff between runs, to
deduplicate, and to upsert into a table you maintain over time. Because the identifiers the source uses are
preserved verbatim, the dataset joins cleanly onto other sources keyed on the same identifier, and a scheduled
run keeps the downstream copy current with no manual reconciliation - the new and changed rows simply upsert
over the old ones, and the `observed_at` stamp on every record tells you when each was last seen live.

### Inputs

- **Maximum records** (`maxRecords`) - hard cap on organisation records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A tabular
overview surfaces EIN, name, state, subsection, classification, status and the asset/income bands.

### Fields in detail

The record leads with `ein` and `name`, then the address (`street`, `city`, `state`, `zip`), the
classification block (`group`, `subsection`, `affiliation`, `classification`, `ruling`, `deductibility`,
`foundation`, `activity`, `organization`, `status`), `tax_period`, and the `asset_cd`/`income_cd`/`filing_req_cd`
/`pf_filing_req_cd` bands. The provenance block closes every record.

### Typical uses

Grant-makers, KYC and nonprofit-analytics teams use this cell as the authoritative roster of U.S. tax-exempt
organisations - status, type and size band for nearly two million EINs, keyed for lookup or bulk screening.
Because the subsection, status and asset band are first-class fields, a filter gives every active 501(c)(3) in
a state above an asset threshold without cleaning, and the EIN joins to 990 filings for financial detail. A
scheduled run keeps a downstream registry current as the IRS republishes the BMF.

### Six extracts, one dataset

The IRS splits the BMF into six regional CSVs - four U.S. regions plus Puerto Rico and an international file -
purely for file-size reasons; they share one schema. This cell reads all six in turn and delivers them as a
single dataset keyed on the EIN, so you get the complete national roster in one run rather than stitching six
files together yourself. The EIN is the federal identifier for the organisation and never changes, which makes
the dataset safe to upsert and to join against any other EIN-keyed source.

### Reading the codes

The BMF is a coded file: `subsection` is the IRC subsection (03 for 501(c)(3), and so on), `status` the
exemption status, `foundation` the private-foundation type, and `asset_cd`/`income_cd` are size bands rather
than exact dollar figures. Keeping them as the IRS's own code values (rather than guessing at decoded labels)
is faithful to the source; the IRS publishes the code tables that map each value, and the classification field
carries the NTEE-style activity coding. A filter on subsection and status gives, for example, every active
501(c)(3) in a state, and the asset band narrows it to organisations of a given size.

### Why the registry view matters

For KYC and grant-making, the question is usually "is this organisation currently exempt, of what type, and
roughly how large" - which is exactly what the BMF answers, for nearly two million EINs, in one flat table.
The 990 filings add the financial detail when you need it, joined on the EIN; but the registry view is the
faster screen, and it covers organisations that have not yet filed a 990. A scheduled run keeps the roster
current as the IRS republishes the extract.

### Sibling Actors

It sits beside the fleet's ProPublica IRS-990 cells, which carry the 990 filing financials (~60% roster overlap, distinct field grain - registry status/NTEE/asset-class vs filing line-items). It shares its multi-CSV engineering with the fleet's other records Actors.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records actually delivered. Raise it to pull the full set.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

The delivered US exempt organization master record.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/us-exempt-organization-master-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/us-exempt-organization-master-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/us-exempt-organization-master-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/us-exempt-organization-master-records"
        }
    }
}

```

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/oi4iM13lp6VqLkEST/builds/KxGKkBS35OKwpPxhj/openapi.json