# SAM.gov Federal Contractor Entity Scraper (`haketa/sam-gov-federal-contractor-scraper`) Actor

Scrape federal contractor registrations from SAM.gov API. Search by NAICS code, state, business type, certification and more. Extract UEI, CAGE code, business names, addresses, NAICS codes, small business certifications and exclusion status. Requires free SAM.gov API key.

- **URL**: https://apify.com/haketa/sam-gov-federal-contractor-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Developer tools, Lead generation, Other
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## SAM.gov Federal Contractor Entity Scraper

### What does SAM.gov Federal Contractor Scraper do?

SAM.gov Federal Contractor Scraper extracts **federal contractor entity registrations** from the [SAM.gov Entity Management API](https://sam.gov/) — the official U.S. government system where every company that wants to do business with the federal government must register. It returns structured data including UEI numbers, CAGE codes, legal and trade names, NAICS industry codes, small business certifications, exclusion (debarment) status, and physical addresses.

The scraper supports **powerful filtering** by NAICS code, state, city, business type certification, registration date range, and exclusion status — letting you pull precisely the entities you need from SAM.gov's database of **600,000+ active registrations**.

Requires a **free SAM.gov API key** (takes 2 minutes to get — no federal account needed for public data).

### Why scrape SAM.gov entity data?

SAM.gov is the **gateway to the $750B+ U.S. federal contracting market**. Every company that bids on federal contracts, receives grants, or serves as a government vendor must maintain an active SAM registration. This makes SAM.gov the most comprehensive database of federal market participants in existence.

Here's why this data is valuable:

- 💼 **GovTech sales teams** — Find federal contractors by industry (NAICS) and location. A query like "Active IT firms in Texas" returns a CRM-ready lead list in minutes
- 📋 **Federal bid/proposal teams** — Analyze competitors in your NAICS codes. See how many firms compete in your space, their certifications, and locations
- ✅ **Compliance & vendor risk teams** — Verify SAM registration status and check exclusion (debarment) flags during vendor onboarding. Automate what today takes manual lookups
- 🤝 **Prime contractors seeking subs** — Federal contracts require small business subcontracting goals. Find "HUBZone certified, Construction, Virginia" firms in one query
- 📊 **Policy researchers & lobbyists** — Track federal market entry trends by sector, state, and year using registration date filters
- 🏷️ **Certification-based targeting** — Filter by Woman-Owned, Veteran-Owned, 8(a), HUBZone, Service-Disabled Veteran-Owned and other SBA certifications

The Apify platform adds **scheduling, API access, webhook integrations, and proxy rotation** — turning a manual SAM.gov search into an automated intelligence pipeline.

### How to scrape SAM.gov entity data

1. **Get a free API key**: Go to [sam.gov](https://sam.gov), create an account, navigate to Profile, and generate a Public API key. Takes about 2 minutes
2. Go to the [SAM.gov Federal Contractor Scraper](https://apify.com/haketa/sam-gov-federal-contractor-scraper) on Apify Store
3. Click **Try for free** and paste your API key into the input
4. Set your filters — NAICS code, state, city, business type, date range
5. Set **Max Records** (up to 10,000 per query) and click **Start**
6. Download your dataset in **JSON, CSV, Excel, or XML** — or connect via API

💡 **Pro tip**: Combine NAICS code + state + business type for laser-focused results. Example: `naicsCode=541512`, `stateCode=VA`, `businessType=Small Business` returns small IT firms in Virginia that are SAM-registered.

### What data can you extract from SAM.gov?

| Field | Description | Example |
|---|---|---|
| UEI (SAM) | 12-digit Unique Entity Identifier | `ZQGGHJH74DW7` |
| CAGE Code | 5-digit govt entity code | `855J5` |
| Legal Business Name | Legal entity name | `ACME ENGINEERING LLC` |
| DBA Name | Doing Business As / trade name | `ACME Solutions` |
| Registration Status | Active or Expired | `Active` |
| Registration Date | Initial registration (YYYY-MM-DD) | `2021-03-15` |
| Expiration Date | Registration expiry (YYYY-MM-DD) | `2025-03-14` |
| Purpose of Registration | Contract type eligibility | `All Awards` |
| Excluded (Debarred) | Debarment/suspension flag | `false` |
| Entity Structure | Business structure | `Limited Liability Company` |
| State of Incorporation | Where entity is incorporated | `TX` |
| Primary NAICS | Main industry code | `541330` |
| All NAICS Codes | All registered industry codes | `["541330", "541519"]` |
| Business Types | Certifications and categories | `["Small Business", "Woman Owned"]` |
| Street | Physical address | `1234 Main St` |
| City | City | `Houston` |
| State | State code | `TX` |
| ZIP Code | Postal code | `77001` |
| Country | Country code | `USA` |

### Common NAICS codes for SAM.gov searches

| NAICS | Industry | Typical registrations |
|---|---|---|
| `541512` | Computer Systems Design | IT contractors |
| `541330` | Engineering Services | Engineering firms |
| `541611` | Admin Management Consulting | Management consultants |
| `236220` | Commercial Building Construction | General contractors |
| `238210` | Electrical Contractors | Electrical |
| `561210` | Facilities Support Services | Facility management |
| `541519` | Other Computer Related Services | IT services |
| `561612` | Security Guards & Patrol Services | Security firms |
| `541990` | All Other Professional Services | Misc professional |

### SAM.gov business type certifications

The `businessTypes` field contains SBA and other federal certifications. Common values you can filter by:

`Small Business`, `Woman Owned Business`, `Veteran Owned Business`, `Service Disabled Veteran Owned Business`, `8(a)`, `HUBZone`, `Economically Disadvantaged Woman Owned Small Business`, `Self Certified Small Disadvantaged Business`, `Minority Owned Business`, `Native American Owned`, `Asian Pacific American Owned`, `Black American Owned`

### Output example

```json
{
  "ueiSAM": "ZQGGHJH74DW7",
  "cageCode": "855J5",
  "legalBusinessName": "ACME ENGINEERING LLC",
  "dbaName": "ACME Solutions",
  "registrationStatus": "Active",
  "registrationDate": "2021-03-15",
  "expirationDate": "2025-03-14",
  "activationDate": "2024-03-20",
  "purposeOfRegistration": "All Awards",
  "isExcluded": false,
  "entityStructure": "Limited Liability Company",
  "stateOfIncorporation": "TX",
  "primaryNaics": "541330",
  "naicsCodes": ["541330", "541519"],
  "businessTypes": ["Small Business", "Woman Owned Business"],
  "street": "1234 Main St",
  "city": "Houston",
  "state": "TX",
  "zipCode": "77001",
  "country": "USA",
  "scrapedAt": "2026-04-23T09:00:00.000Z"
}
````

### How much does it cost to scrape SAM.gov?

SAM.gov Federal Contractor Scraper uses a **pay-per-result** pricing model:

| Plan | Price per 1,000 records | Example: 5,000 records | Example: 10,000 records |
|---|---|---|---|
| Free (No discount) | $5.00 | $25 | $50 |
| Bronze | $4.50 | $22.50 | $45 |
| Silver | $4.00 | $20 | $40 |
| Gold | $3.50 | $17.50 | $35 |

**Why is SAM.gov data priced higher?** Because it includes UEI + CAGE codes (unique federal identifiers), small business certification flags, exclusion/debarment status, and NAICS-filtered targeting across the entire U.S. federal marketplace. This is intelligence-grade data for the $750B federal contracting market.

The SAM.gov API key is **free**. The Actor runs on **~0.01 CU per 1,000 records** — API overhead is minimal.

### Input configuration

Click on the [Input tab](https://apify.com/haketa/sam-gov-federal-contractor-scraper/input-schema) for full details. Key parameters:

| Parameter | Default | Description |
|---|---|---|
| API Key | *(required)* | Free SAM.gov API key |
| Registration Status | `Active` | Active, Expired, or All |
| NAICS Code | *(empty)* | Industry filter (e.g., `541330`) |
| State Code | *(empty)* | US state (e.g., `TX`) |
| City | *(empty)* | City filter |
| Business Type | *(empty)* | Certification (e.g., `Woman Owned Business`) |
| Exclude Debarred | `true` | Skip excluded/debarred entities |
| Max Records | `200` | Up to 10,000 per query |
| Request Delay | `600` ms | Delay between API calls |

### Integrations and API access

Connect SAM.gov Federal Contractor Scraper with any cloud service via Apify's built-in [integrations](https://apify.com/integrations). Connect with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and more. Access datasets programmatically via the [Apify API](https://docs.apify.com/api).

**Recommended workflow**: Schedule a monthly run filtered by `registrationDateFrom` = first of last month → pipe new SAM registrations into your CRM via webhook → instant lead alerts for newly registered federal contractors.

### FAQ

#### How do I get a SAM.gov API key?

Go to [sam.gov](https://sam.gov), click "Sign In" (or create an account), navigate to your Profile page, and scroll to the API Key section. Generate a "Public API Key" — it's free and instant. No federal employee account needed.

#### What's the difference between UEI and DUNS?

**UEI (Unique Entity Identifier)** replaced the DUNS number in April 2022 as the official federal entity identifier. UEI is a 12-character alphanumeric code assigned by SAM.gov. All SAM records now use UEI. This Actor returns the UEI in the `ueiSAM` field.

#### What does "excluded" mean?

An excluded entity has been **debarred or suspended** from federal contracting — meaning they cannot receive new federal contracts or subcontracts. The `isExcluded` field flags these entities. Use `excludeExcluded: true` (default) to filter them out, or set it to `false` if you specifically need to find debarred entities for compliance screening.

#### What's the maximum number of records I can extract?

The SAM.gov sync API supports up to **10,000 records per query**. For larger datasets, narrow your search with NAICS codes, state filters, or date ranges to stay within the limit. Each filtered query can return up to 10,000 results.

#### Is SAM.gov data public?

Yes. SAM.gov entity registration data at the Public tier is **freely accessible** with a registered API key. No sensitive information (like bank accounts or tax IDs) is included in the public data. This Actor only accesses the public data tier.

#### Where can I get support?

For issues or feature requests, use the **Issues tab** on the Actor page. I actively monitor feedback and respond promptly.

### Other scrapers

Looking for more license, permit, and contractor data? Check out:

- 🍷 [TTB Alcohol Permit Scraper](https://apify.com/haketa/ttb-alcohol-permittee-scraper) — Federal alcohol permits for wineries, distilleries, importers, and wholesalers
- 🏛️ [Virginia DPOR License Scraper](https://apify.com/haketa/virginia-dpor-license-scraper) — 45K+ contractor and tradesman license records from Virginia
- 🏗️ [Minnesota DLI License Scraper](https://apify.com/haketa/minnesota-dli-license-scraper) — 200K+ contractor, electrician, plumber, and HVAC bond records from Minnesota

# Actor input Schema

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

Your SAM.gov public API key. Get one for free at https://sam.gov — register an account, go to Profile, and generate an API key. Required.

## `registrationStatus` (type: `string`):

Filter by registration status. 'A' = Active only, 'E' = Expired only, 'all' = both.

## `naicsCode` (type: `string`):

Filter by NAICS industry code. Examples: '541330' (Engineering Services), '541512' (Computer Systems Design), '236220' (Commercial Building Construction), '238210' (Electrical Contractors). Leave empty for all industries.

## `stateCode` (type: `string`):

Filter by US state code. Examples: 'TX', 'CA', 'VA', 'NY'. Leave empty for all states.

## `city` (type: `string`):

Filter by city name. Example: 'Houston', 'San Francisco'. Leave empty for all cities.

## `businessType` (type: `string`):

Filter by business type or certification. Examples: 'Small Business', 'Woman Owned Business', 'Veteran Owned Business', 'HUBZone', '8(a)', 'Service Disabled Veteran Owned Business'. Leave empty for all types.

## `excludeExcluded` (type: `boolean`):

Exclude entities with active exclusions (debarred/suspended from federal contracting).

## `registrationDateFrom` (type: `string`):

Only return entities registered on or after this date. Format: MM/DD/YYYY. Example: '01/01/2024'. Leave empty for no date filter.

## `registrationDateTo` (type: `string`):

Only return entities registered on or before this date. Format: MM/DD/YYYY. Leave empty for no date filter.

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

Maximum records to save. SAM.gov sync API supports up to 10,000 records per query. Set 0 for maximum available.

## `pageSize` (type: `integer`):

Records per API page. SAM.gov maximum is 10.

## `requestDelay` (type: `integer`):

Delay between API requests in milliseconds. SAM.gov has rate limits — keep above 500ms to avoid throttling.

## `proxyConfiguration` (type: `object`):

Optional proxy settings.

## Actor input object example

```json
{
  "registrationStatus": "A",
  "excludeExcluded": true,
  "maxRecords": 200,
  "pageSize": 10,
  "requestDelay": 600,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `ueiSAM` (type: `string`):

12-digit Unique Entity Identifier (replaced DUNS in 2022)

## `cageCode` (type: `string`):

5-digit Commercial and Government Entity code

## `legalBusinessName` (type: `string`):

Legal entity name

## `dbaName` (type: `string`):

Doing Business As / trade name

## `registrationStatus` (type: `string`):

Active or Expired

## `registrationDate` (type: `string`):

Initial registration date (YYYY-MM-DD)

## `expirationDate` (type: `string`):

Registration expiration date (YYYY-MM-DD)

## `activationDate` (type: `string`):

Most recent activation date (YYYY-MM-DD)

## `purposeOfRegistration` (type: `string`):

All Awards, Federal Assistance Awards, etc.

## `isExcluded` (type: `string`):

true if entity is debarred/suspended

## `entityStructure` (type: `string`):

LLC, Corporation, Sole Proprietorship, etc.

## `stateOfIncorporation` (type: `string`):

State where entity is incorporated

## `primaryNaics` (type: `string`):

Primary 6-digit NAICS industry code

## `naicsCodes` (type: `string`):

All NAICS codes registered (array)

## `businessTypes` (type: `string`):

Business types and certifications (array)

## `street` (type: `string`):

Physical address street

## `city` (type: `string`):

Physical address city

## `state` (type: `string`):

Physical address state code

## `zipCode` (type: `string`):

Physical address ZIP code

## `country` (type: `string`):

Country code (USA, etc.)

## `scrapedAt` (type: `string`):

ISO timestamp when record was scraped

# 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 = {
    "naicsCode": "",
    "stateCode": "",
    "city": "",
    "businessType": "",
    "registrationDateFrom": "",
    "registrationDateTo": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/sam-gov-federal-contractor-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 = {
    "naicsCode": "",
    "stateCode": "",
    "city": "",
    "businessType": "",
    "registrationDateFrom": "",
    "registrationDateTo": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/sam-gov-federal-contractor-scraper").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 '{
  "naicsCode": "",
  "stateCode": "",
  "city": "",
  "businessType": "",
  "registrationDateFrom": "",
  "registrationDateTo": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/sam-gov-federal-contractor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SAM.gov Federal Contractor Entity Scraper",
        "description": "Scrape federal contractor registrations from SAM.gov API. Search by NAICS code, state, business type, certification and more. Extract UEI, CAGE code, business names, addresses, NAICS codes, small business certifications and exclusion status. Requires free SAM.gov API key.",
        "version": "0.0",
        "x-build-id": "Rsjr9sgYFin0rpwWg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~sam-gov-federal-contractor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-sam-gov-federal-contractor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/haketa~sam-gov-federal-contractor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-sam-gov-federal-contractor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/haketa~sam-gov-federal-contractor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-sam-gov-federal-contractor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "apiKey": {
                        "title": "SAM.gov API Key",
                        "type": "string",
                        "description": "Your SAM.gov public API key. Get one for free at https://sam.gov — register an account, go to Profile, and generate an API key. Required."
                    },
                    "registrationStatus": {
                        "title": "Registration Status",
                        "enum": [
                            "A",
                            "E",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by registration status. 'A' = Active only, 'E' = Expired only, 'all' = both.",
                        "default": "A"
                    },
                    "naicsCode": {
                        "title": "NAICS Code",
                        "type": "string",
                        "description": "Filter by NAICS industry code. Examples: '541330' (Engineering Services), '541512' (Computer Systems Design), '236220' (Commercial Building Construction), '238210' (Electrical Contractors). Leave empty for all industries."
                    },
                    "stateCode": {
                        "title": "State Code",
                        "type": "string",
                        "description": "Filter by US state code. Examples: 'TX', 'CA', 'VA', 'NY'. Leave empty for all states."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by city name. Example: 'Houston', 'San Francisco'. Leave empty for all cities."
                    },
                    "businessType": {
                        "title": "Business Type / Certification",
                        "type": "string",
                        "description": "Filter by business type or certification. Examples: 'Small Business', 'Woman Owned Business', 'Veteran Owned Business', 'HUBZone', '8(a)', 'Service Disabled Veteran Owned Business'. Leave empty for all types."
                    },
                    "excludeExcluded": {
                        "title": "Exclude Debarred Entities",
                        "type": "boolean",
                        "description": "Exclude entities with active exclusions (debarred/suspended from federal contracting).",
                        "default": true
                    },
                    "registrationDateFrom": {
                        "title": "Registration Date From",
                        "type": "string",
                        "description": "Only return entities registered on or after this date. Format: MM/DD/YYYY. Example: '01/01/2024'. Leave empty for no date filter."
                    },
                    "registrationDateTo": {
                        "title": "Registration Date To",
                        "type": "string",
                        "description": "Only return entities registered on or before this date. Format: MM/DD/YYYY. Leave empty for no date filter."
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to save. SAM.gov sync API supports up to 10,000 records per query. Set 0 for maximum available.",
                        "default": 200
                    },
                    "pageSize": {
                        "title": "Page Size",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Records per API page. SAM.gov maximum is 10.",
                        "default": 10
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between API requests in milliseconds. SAM.gov has rate limits — keep above 500ms to avoid throttling.",
                        "default": 600
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
