# Federal Audit Clearinghouse API (`automation-lab/federal-audit-clearinghouse-scraper`) Actor

Filter and export official FAC single-audit submissions, auditees, auditors, federal awards, findings, and corrective-action records.

- **URL**: https://apify.com/automation-lab/federal-audit-clearinghouse-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.91 / 1,000 item extracteds

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

## Federal Audit Clearinghouse API

Export official Federal Audit Clearinghouse (FAC) single-audit data without building your own FAC API integration. Filter submissions, auditees, primary and secondary auditors, federal awards, findings, finding narratives, and corrective-action plans into one Apify dataset.

The Actor is designed for recurring grant-risk monitoring, compliance research, due diligence, and reproducible data pipelines. It queries the public FAC API directly and preserves the complete official source row inside each result.

### What does this Federal Audit Clearinghouse Actor do?

The Actor turns FAC's technical public endpoints into a validated Apify input and a consistent dataset.

You can:

- search audit submissions by year, state, entity type, auditee name, UEI, acceptance date, or total federal expenditures;
- retrieve one or more known FAC reports by stable report ID;
- export federal award rows and their program, cluster, expenditure, loan, direct-award, and finding fields;
- collect finding flags, finding narratives, and management corrective actions;
- export primary audit-firm details from submissions and secondary-auditor rows;
- schedule the same filters and compare datasets over time;
- send results to spreadsheets, databases, webhooks, or another Actor.

No FAC login or API key is required. The Actor uses Data.gov's shared `DEMO_KEY` first and automatically falls back to FAC's anonymous search and per-report workbooks when that shared quota is exhausted. For faster scheduled or high-volume use, add your own free Data.gov API key to get a private request quota.

### Who is this Actor for?

- **Grant compliance teams** tracking recipients with findings, questioned costs, repeat findings, or material weaknesses.
- **Due-diligence analysts** checking an organization's audit history and federal expenditure profile.
- **CPA and audit-market researchers** mapping audited entities to primary and secondary audit firms.
- **Federal program teams** exporting awards and findings tied to an Assistance Listing or program.
- **Investigative and academic researchers** building reproducible extracts from official public records.
- **Data engineers** replacing manual CSV downloads with scheduled typed datasets.

### Why use the Actor instead of downloading FAC CSV files?

FAC's bulk files are valuable, but current tables can be hundreds of megabytes or more than one gigabyte. Repeatedly downloading and joining them is inefficient when you need a bounded slice.

This Actor:

1. sends filters to the official JSON API;
2. paginates only until `maxItems` is reached;
3. validates filter syntax before making requests;
4. resolves matching report IDs when a related table lacks state, name, entity-type, or total-expenditure columns;
5. adds consistent top-level fields for filtering in Apify;
6. keeps the complete original FAC row under `data`.

The Actor does not infer risk scores, enrich records with private data, or claim that an audit finding proves wrongdoing.

### What Federal Audit Clearinghouse data can I extract?

| Record type | Input value | Typical fields |
| --- | --- | --- |
| Audit submissions | `audits` | Auditee name, UEI, EIN, address, contact, primary auditor, audit period, opinions, risk flags, total amount expended |
| Federal awards | `federalAwards` | Award reference, agency prefix, program name, cluster, amount expended, direct/major/loan flags, finding count |
| Findings | `findings` | Finding reference, award reference, material weakness, modified opinion, questioned costs, repeat finding, deficiency flags |
| Finding details | `findingDetails` | Finding reference, finding text, context fields supplied by FAC |
| Corrective actions | `correctiveActions` | Finding reference, chart/table flag, management's planned action |
| Secondary auditors | `secondaryAuditors` | Auditor name, EIN, contact details, and address |

Every result includes `recordType`, `reportId`, `auditeeUei`, `auditYear`, `acceptedDate`, `sourceUrl`, `fetchedAt`, and `data`. Type-specific convenience fields are populated when available and otherwise remain `null`.

### Getting started

1. Open the Actor in Apify Console.
2. Choose one or more **Record types**.
3. Add filters such as audit year, state, auditee name, UEI, or FAC report ID.
4. Set **Maximum records** to control dataset size and cost.
5. Optionally add a free Data.gov API key for a private quota.
6. Click **Start**.
7. Open the **FAC records** dataset view or export the dataset as JSON, CSV, Excel, XML, or RSS.

A safe first run is:

```json
{
  "recordTypes": ["audits"],
  "auditYears": [2024],
  "states": ["CA"],
  "entityTypes": ["non-profit"],
  "maxItems": 10
}
```

### Input parameters

| Field | Type | Default | Meaning |
| --- | --- | --- | --- |
| `recordTypes` | string array | `["audits"]` | FAC collections to export |
| `reportIds` | string array | empty | Exact IDs such as `2023-01-GSAFAC-0000000854` |
| `auditYears` | integer array | empty | Audit years from 2016 onward |
| `states` | string array | empty | Two-letter auditee state or territory codes |
| `entityTypes` | string array | empty | State, local, tribal, higher education, nonprofit, or unknown |
| `auditeeUeis` | string array | empty | Exact 12-character Unique Entity Identifiers |
| `auditeeName` | string | empty | Case-insensitive organization name fragment |
| `acceptedFrom` | date | empty | Earliest FAC acceptance date, inclusive |
| `acceptedTo` | date | empty | Latest FAC acceptance date, inclusive |
| `minTotalAmountExpended` | number | empty | Minimum total federal expenditures in USD |
| `maxItems` | integer | `100` | Maximum records across all selected types, from 1 to 10,000 |
| `apiKey` | secret string | shared demo key | Optional free Data.gov key for private request limits |

General-only filters such as state, entity type, auditee name, and minimum total expenditures also work for related record types. The Actor first finds matching audit report IDs and then constrains the selected related endpoint.

### Output example

The following shortened example reflects the Actor's output shape. The nested `data` object contains all fields returned by FAC for that collection.

```json
{
  "recordType": "federalAwards",
  "reportId": "2023-01-GSAFAC-0000000854",
  "auditeeUei": "MW4NM5KU2M81",
  "auditYear": 2023,
  "acceptedDate": "2023-10-12",
  "auditeeName": null,
  "auditeeState": null,
  "totalAmountExpended": null,
  "federalProgramName": "CONSOLIDATED HEALTH CENTERS",
  "amountExpended": 5077742,
  "findingReference": null,
  "plannedAction": null,
  "auditorName": null,
  "sourceUrl": "https://app.fac.gov/dissemination/summary/2023-01-GSAFAC-0000000854",
  "fetchedAt": "2026-08-13T12:00:00.000Z",
  "data": {
    "report_id": "2023-01-GSAFAC-0000000854",
    "award_reference": "AWARD-0001",
    "federal_agency_prefix": "93",
    "amount_expended": 5077742
  }
}
```

Contact fields can be present in public FAC submissions. Handle them only for a legitimate research or compliance purpose and follow applicable rules.

### How filtering related records works

Fields differ between FAC collections. For example, `federal_awards` has a report ID and UEI but not the auditee's state.

When you request awards for `states: ["TX"]`, the Actor:

1. queries `general` with the Texas filter;
2. collects matching FAC report IDs;
3. queries `federal_awards` only for those IDs;
4. stops when the overall `maxItems` limit is reached.

This is an exact source join on FAC report IDs, not a fuzzy organization-name match.

When multiple record types are selected, they are processed in the order shown in the input. Because `maxItems` applies globally, use separate runs if every collection needs its own independent limit.

### How much does it cost to export Federal Audit Clearinghouse records?

Pricing uses one `$0.0001` start event and one `item` event for each saved dataset row. Rejected, duplicate, empty, or failed records are not charged as items.

Current item prices decrease by Apify plan:

| Plan | Price per saved record |
| --- | ---: |
| FREE | $0.003657 |
| BRONZE | $0.00318 |
| SILVER | $0.0024804 |
| GOLD | $0.001908 |
| PLATINUM | $0.001272 |
| DIAMOND | $0.0008904 |

On BRONZE, approximate Actor charges are:

- 10 records: `$0.0319` including the start event;
- 100 records: `$0.3181` including the start event;
- 1,000 records: `$3.1801` including the start event.

Apify platform usage and any costs associated with your own integrations are separate. A run that performs a report-ID join may make an extra FAC request but does not create a separate Actor charge event.

### Scheduling grant-risk monitoring

Use an Apify Schedule for a repeatable monitor:

1. choose a narrow acceptance window, state, entity type, or known UEIs;
2. select `findings`, `findingDetails`, or `correctiveActions`;
3. set a result limit appropriate for the expected window;
4. run daily, weekly, or monthly;
5. connect a webhook or integration to compare the new dataset with prior results.

The Actor returns current source data. It does not maintain a historical change database by itself. Your workflow should retain prior datasets if change detection is required.

### Export and integration patterns

Useful patterns include:

- export audit submissions to Google Sheets for review;
- load award rows into BigQuery, Snowflake, PostgreSQL, or a data lake;
- trigger a webhook when a scheduled dataset contains repeat findings;
- join FAC `auditeeUei` with federal spending or organization reference data;
- group primary and secondary auditors for audit-market analysis;
- send finding narratives to a controlled internal review workflow.

Apify's dataset API supports JSON, JSONL, CSV, Excel, XML, and RSS output formats.

### Run with the Apify API

Replace `APIFY_TOKEN` with your Apify token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~federal-audit-clearinghouse-scraper/run-sync-get-dataset-items?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"recordTypes":["findings"],"auditYears":[2024],"states":["TX"],"maxItems":25}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/federal-audit-clearinghouse-scraper').call({
  recordTypes: ['federalAwards'],
  reportIds: ['2023-01-GSAFAC-0000000854'],
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("automation-lab/federal-audit-clearinghouse-scraper").call(run_input={
    "recordTypes": ["audits"],
    "auditYears": [2024],
    "entityTypes": ["higher-ed"],
    "maxItems": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/federal-audit-clearinghouse-scraper"
```

#### Claude Desktop

Add this server to your Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/federal-audit-clearinghouse-scraper"
    }
  }
}
```

#### Cursor

Add the same `mcpServers.apify.url` value to Cursor's MCP settings, then enable the `apify` server.

#### VS Code

Add the same HTTP endpoint as an MCP server in your VS Code MCP configuration and start the server from the MCP panel.

Example prompts:

- "Export 2024 Texas nonprofit FAC audits with at least $2 million in federal expenditures."
- "Get federal award rows for FAC report 2023-01-GSAFAC-0000000854."
- "Find 2023 California audit findings and include the official source links."

### Limits and expected failure behavior

- The current GSA FAC data covers 2016 onward; historic Census bulk files are outside this Actor's current contract.
- The shared Data.gov `DEMO_KEY` has a low, shared request quota. On HTTP 429, the Actor automatically retrieves the same official records through FAC's anonymous search and per-report XLSX exports.
- The fallback downloads a workbook for each matching report, so a free private Data.gov API key is faster for scheduled, concurrent, or larger runs.
- FAC can change its schema. The Actor preserves new source fields in `data`, while stable convenience fields remain backward compatible.
- `maxItems` applies across selected record types rather than separately to each type.
- Very broad joins can resolve only the bounded set of report IDs needed for the requested output limit.
- The Actor does not download audit PDFs or provide legal conclusions.
- FAC may suppress records that are not public; the Actor cannot return unavailable records.

Malformed filters fail before extraction. Deterministic HTTP errors are not retried blindly. HTTP 429 and transient server errors receive bounded retries, then the run fails rather than returning a misleading partial success.

### Troubleshooting

#### What happens when the shared Data.gov key is rate limited?

The Actor switches automatically to FAC's anonymous public search and official per-report XLSX exports, preserving complete source rows without requiring a credential. This route can be slower because it downloads one small workbook per matching audit. For high-volume or scheduled runs, request a free Data.gov key and paste it into the secret `apiKey` input. The key is used only in the request header and is not written to the dataset or logs.

#### Why are some convenience fields null?

FAC collections have different columns. Award rows contain program and award expenditure fields but not the auditee name or state. The complete source row is always available under `data`.

#### Why did I get fewer records than expected?

Check `maxItems`, acceptance dates, entity type spelling, UEIs, and report IDs. Also remember that the limit is shared across all selected record types.

#### Can I query records before 2016?

Not with this version. FAC publishes a separate historic Census dataset with a different schema. Mixing the two would create false field equivalence, so the Actor currently keeps a clear 2016+ scope.

### Responsible use and legality

FAC states that its collected data is public domain. Public availability does not remove every responsibility.

- Use data for a lawful compliance, research, reporting, or due-diligence purpose.
- Follow applicable privacy, anti-discrimination, records-retention, and outreach rules.
- Do not treat an audit finding as proof of fraud or misconduct.
- Verify material decisions against the official FAC summary and underlying audit documentation.
- Protect contact details and avoid unsolicited or abusive use.
- Respect FAC and Data.gov service limits.

This Actor is an independent automation tool and is not affiliated with or endorsed by GSA, FAC, or Data.gov.

### Frequently asked questions

#### Does the Actor require a FAC account?

No. It reads public dissemination data and never uses the audit-submission login.

#### Does it require a proxy or browser?

No. It uses the official HTTPS JSON API and FAC's anonymous public report exports directly. There is no residential-proxy fallback.

#### Can it search by organization name?

Yes. `auditeeName` performs a case-insensitive FAC API match. Parentheses, commas, and wildcard characters are rejected to keep query semantics predictable.

#### Can it export auditors?

Yes. Primary audit-firm and contact fields are part of `audits`; select `secondaryAuditors` for separate secondary-auditor records.

#### Does it calculate a risk score?

No. It returns official fields such as repeat-finding, material-weakness, questioned-cost, opinion, and low-risk-auditee indicators. Interpret them in context.

### Related automation-lab Actors

- [USAspending Scraper](https://apify.com/automation-lab/usaspending-scraper) — retrieve federal spending records for award and recipient context.
- [USAspending Subawards Scraper](https://apify.com/automation-lab/usaspending-subawards-scraper) — inspect subaward relationships tied to federal funding.
- [USAspending Loans Scraper](https://apify.com/automation-lab/usaspending-loans-scraper) — export federal loan assistance records.

Use FAC for audit opinions, findings, auditors, and corrective actions; use USAspending Actors when transaction or award-spending context is the primary job.

# Actor input Schema

## `recordTypes` (type: `array`):

FAC record collections to export. The maximum item count applies across all selected types in this order.

## `reportIds` (type: `array`):

Optional exact FAC report IDs, such as 2023-01-GSAFAC-0000000854.

## `auditYears` (type: `array`):

Optional audit years. Leave empty to include every year in the current GSA FAC dataset (2016 onward).

## `states` (type: `array`):

Two-letter US state or territory codes. For related records, the Actor first resolves matching submissions.

## `entityTypes` (type: `array`):

Optional auditee organization types.

## `auditeeUeis` (type: `array`):

Optional exact 12-character Unique Entity Identifiers.

## `auditeeName` (type: `string`):

Case-insensitive organization-name text filter. For related records, matching report IDs are resolved first.

## `acceptedFrom` (type: `string`):

Only records accepted by FAC on or after this date.

## `acceptedTo` (type: `string`):

Only records accepted by FAC on or before this date.

## `minTotalAmountExpended` (type: `number`):

Minimum total federal expenditures on an audit submission, in USD. Related records are joined through matching report IDs.

## `maxItems` (type: `integer`):

Maximum total dataset records to save across all selected record types.

## `apiKey` (type: `string`):

Optional free Data.gov API key for a private request quota. If the shared key is rate limited, the Actor automatically uses FAC's anonymous search and report workbooks.

## Actor input object example

```json
{
  "recordTypes": [
    "audits"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

All official FAC records saved by this run.

# 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 = {
    "recordTypes": [
        "audits"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/federal-audit-clearinghouse-scraper").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 = {
    "recordTypes": ["audits"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/federal-audit-clearinghouse-scraper").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 '{
  "recordTypes": [
    "audits"
  ],
  "maxItems": 10
}' |
apify call automation-lab/federal-audit-clearinghouse-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/federal-audit-clearinghouse-scraper"
        }
    }
}

```

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/LutZLyeKkHJfXQtiZ/builds/SDhIv5UBXvGb9yBba/openapi.json