# PPP Loan Finder API - 11M US SMBs + Enrichment (`makework36/ppp-loan-finder`) Actor

Search 11M+ US small businesses that received COVID PPP loans (SBA data). Filter by state, name, industry, amount. Optional website & email enrichment.

- **URL**: https://apify.com/makework36/ppp-loan-finder.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ppp loan records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## PPP Loan Finder API — 11M US SMBs + Enrichment

Search the public **SBA Paycheck Protection Program (PPP)** loan database — over **11 million U.S. small businesses** that received COVID-era loans — and turn it into a clean, queryable lead list. Filter by state, company name, industry (NAICS), business type, city or loan amount. Optionally enrich every borrower with a website, LinkedIn, Facebook and secondary emails.

This actor is the fastest path from "I need a list of small business owners in the US" to a fully-enriched CSV of real, verified companies — with phone-quality data quality, free SBA-FOIA provenance, and no proprietary signup wall.

If you have searched for **PPP loan database**, **PPP loan lookup by name free**, **PPP loan list by state**, **PPP recipients by zip code**, **PPP loan search by name**, or **small business email list**, this is the actor. Same data that powers ProPublica's PPP search, Federal Pay, USA Today's PPP database — but exposed as an API you can run on a schedule and export to CSV.

> 💡 The SBA PPP dataset is the largest open dataset of U.S. SMBs that exists. Every funded loan was published under FOIA. This actor wraps it as a real lead-gen tool.

---

### 🚀 Why this PPP Loan Finder API

- **~11M US small business records** — every borrower the SBA published under FOIA after the Paycheck Protection Program ended
- **Two tiers** — loans **over $150K** (~1M big borrowers, full address) and **$150K and under** (~10M small borrowers)
- **Real filters** — state, NAICS industry prefix, business type, city, loan amount range, name substring
- **Demographics included** — race, ethnicity, gender, veteran status, nonprofit flag, rural / urban, HUBZone
- **Servicing + originating lender** — which bank handled the loan (key signal for fintech / banking outbound)
- **Forgiveness info** — forgiveness amount + date when published
- **Web enrichment** — per borrower, find a website, LinkedIn, Facebook, secondary emails via SERP
- **No signup, no API key** — runs against the public-domain SBA dataset
- **Outputs** — Apify Dataset → CSV, JSON, Excel, XML, RSS, HTML

Built for B2B SDRs targeting US SMBs, fintech and lender outbound, payroll / insurance / SaaS vendors, agencies running local-business prospecting, market analysts sizing industries, and journalists / researchers auditing the program.

---

### 📊 What this PPP Loan Finder extracts

| Field | Description |
| --- | --- |
| `loanNumber` | SBA loan number |
| `dateApproved` | Loan approval date |
| `status` | Current loan status (Paid in Full, Charged Off, Exemption 4, …) |
| `statusDate` | Last status update date |
| `borrowerName` | Business legal name |
| `borrowerAddress` | Street address (large tier only) |
| `borrowerCity` | City |
| `borrowerState` | 2-letter state code |
| `borrowerZip` | ZIP code |
| `initialApprovalAmount` | Original loan amount (USD) |
| `currentApprovalAmount` | Current loan amount after revisions |
| `term` | Loan term in months |
| `forgivenessAmount` | Amount forgiven (USD), `null` if not forgiven |
| `forgivenessDate` | Forgiveness date |
| `jobsReported` | Self-reported jobs at application |
| `naicsCode` | NAICS industry code (6 digits) |
| `naicsCategory` | NAICS top-level sector |
| `businessType` | Legal entity (Corporation, LLC, Sole Proprietorship, …) |
| `businessAgeDescription` | Existing > 2 years / New / Existing > 5 years … |
| `franchiseName` | Franchise name if applicable |
| `ruralUrbanIndicator` | `R` rural / `U` urban |
| `hubzoneIndicator` | Whether the business is in a HUBZone |
| `lmiIndicator` | Whether the business is in a low-income area |
| `race` | Borrower race (when disclosed) |
| `ethnicity` | Hispanic / Not Hispanic / Not disclosed |
| `gender` | Female / Male / Not disclosed |
| `veteran` | Veteran / Not veteran / Not disclosed |
| `nonProfit` | Whether the business is a nonprofit |
| `servicingLenderName` | Lender currently servicing the loan |
| `servicingLenderCity` | Servicing lender city |
| `servicingLenderState` | Servicing lender state |
| `originatingLender` | Lender that originated the loan |
| `originatingLenderCity` | Originating lender city |
| `originatingLenderState` | Originating lender state |
| `enrichment.website` | Borrower website (optional) |
| `enrichment.linkedin` | Borrower LinkedIn page (optional) |
| `enrichment.facebook` | Borrower Facebook page (optional) |
| `enrichment.emails` | Secondary emails found via SERP (optional) |
| `enrichment.phone` | Phone number(s) found on the website (optional) |
| `sourceUrl` | Direct link to the SBA record |

---

### 🎯 Loan size tiers

The SBA published PPP loans in two slices because the volume is enormous. Pick the tier that matches your prospecting.

#### `large` — Loans over $150K (~1M records, fastest)

These are the bigger SMBs (10–500 employees typically). Address is included. Best for B2B outbound where deal size > $1K ACV.

```json
{
  "tier": "large",
  "state": "TX",
  "naicsCode": "23",
  "minLoanAmount": 200000,
  "maxLoanAmount": 1000000,
  "maxResults": 500,
  "enrichWithGoogle": true,
  "enrichLimit": 200
}
````

#### `small` — Loans $150K and under (~10M records, state required)

These are the very small businesses: solo operators, contractors, micro-businesses. **State is required** for this tier because otherwise the dataset is too large to scan in a single run.

```json
{
  "tier": "small",
  "state": "FL",
  "city": "Miami",
  "businessType": "LLC",
  "minLoanAmount": 20000,
  "maxResults": 1000
}
```

#### `all` — Both tiers (state required)

For when you need a complete SMB inventory in a given state.

```json
{
  "tier": "all",
  "state": "CA",
  "naicsCode": "72",
  "maxResults": 5000
}
```

***

### 💡 Use cases

This PPP Loan Finder is built for **B2B lead generation, fintech outbound, agency prospecting, and journalism / research** on the U.S. small-business landscape.

- **B2B SDR prospecting against US SMBs** — payroll, accounting, insurance, HR-tech, POS, fintech, ecom-tools, agency services. The SBA dataset is the cleanest national list of real, registered SMBs by industry
- **Small business email list** — combine `enrichWithGoogle: true` with an industry + state filter to build a verified, opt-in-able outreach list (emails come from the borrower's own public website / LinkedIn)
- **Lender refinancing / alternative financing outbound** — pull every SMB whose PPP loan is still active or recently paid off; offer SBA 7(a), invoice factoring, lines of credit
- **Local SEO and digital-agency lead-gen** — small businesses in a city without a website are the highest-converting market for "we build websites" agencies. Filter by `state` + `city`, then look for borrowers where `enrichment.website` is `null`
- **Insurance prospecting** — commercial liability, workers' comp, cyber. Combine `jobsReported >= 5` + industry filter
- **Real estate / commercial leasing** — find borrowers in a market that may need bigger office or warehouse space (use `jobsReported` and `currentApprovalAmount` as growth signals)
- **CRM enrichment** — match existing accounts on company name + state to pull NAICS, jobs, and lender data
- **Market sizing by industry / region** — count PPP recipients by NAICS and state to estimate the actual operating SMB count in a market
- **List of small business owners in US** — the SBA published the borrower legal name on every funded loan. This is the most exhaustive list that exists, free and FOIA-clean
- **Bank competitive intelligence** — see which banks (servicing + originating lenders) own the SMB relationships in your geography. Use this to target bank reps for partnership deals
- **Journalism / academic research** — audit PPP fraud, demographic disparities, industry concentration. Every record is public-domain

***

### 🧾 Example output

```json
{
  "loanNumber": "1234567890",
  "dateApproved": "2021-02-19",
  "status": "Paid in Full",
  "borrowerName": "Lone Star Construction LLC",
  "borrowerAddress": "1500 Main St",
  "borrowerCity": "Houston",
  "borrowerState": "TX",
  "borrowerZip": "77002",
  "initialApprovalAmount": 285000,
  "currentApprovalAmount": 285000,
  "term": 60,
  "forgivenessAmount": 285000,
  "forgivenessDate": "2022-05-10",
  "jobsReported": 17,
  "naicsCode": "236220",
  "naicsCategory": "Construction",
  "businessType": "Limited Liability Company(LLC)",
  "ruralUrbanIndicator": "U",
  "servicingLenderName": "Chase Bank",
  "originatingLender": "Chase Bank",
  "race": "Not Disclosed",
  "gender": "Male Owned",
  "veteran": "Non-Veteran",
  "nonProfit": false,
  "enrichment": {
    "website": "https://lonestarconstruction.com",
    "linkedin": "https://www.linkedin.com/company/lone-star-construction-tx",
    "facebook": null,
    "emails": ["info@lonestarconstruction.com", "estimating@lonestarconstruction.com"],
    "phone": "+1-713-555-0142"
  },
  "sourceUrl": "https://data.sba.gov/dataset/ppp-foia/loan/1234567890"
}
```

***

### 🆚 Compared to alternatives

| Tool | Loan filters | Demographics | Web enrichment | All states | Export | Cost |
| --- | --- | --- | --- | --- | --- | --- |
| **PPP Loan Finder API** (this actor) | ✅ All fields | ✅ Race, gender, veteran | ✅ Optional | ✅ All 50 | CSV / JSON / Excel | Pay-per-event |
| ProPublica PPP | ⚠️ Limited UI | ⚠️ Partial | ❌ | ✅ | ❌ HTML only | Free, no API |
| FederalPay PPP | ⚠️ Limited UI | ❌ | ❌ | ✅ | ⚠️ Manual CSV | Free, no API |
| USA Today PPP database | ⚠️ Limited UI | ❌ | ❌ | ✅ | ❌ | Free, no API |
| SBA's own portal | ⚠️ Hard to query | ✅ | ❌ | ✅ | ⚠️ Bulk downloads | Free, raw |
| Apollo.io / ZoomInfo | ⚠️ Generic SMB | ❌ | ✅ | ✅ | ✅ | $$$ subscription |

If you only need to look up one company by name, ProPublica or FederalPay are fine. If you need a real list of US SMBs filtered by NAICS, state, loan size and enriched with website + emails, this actor is the fastest path.

***

### ⚙️ Input parameters reference

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `tier` | string enum | `large` | `large` (>$150K) / `small` (≤$150K, state required) / `all` |
| `state` | string | — | 2-letter state code. Required for `small` and `all` |
| `companyNameContains` | string | — | Case-insensitive substring on `borrowerName` |
| `naicsCode` | string | — | NAICS prefix (`23` Construction, `72` Hospitality, `54` Professional services) |
| `businessType` | string | — | `Corporation`, `LLC`, `Sole Proprietorship`, … |
| `minLoanAmount` | integer | — | Minimum `initialApprovalAmount` (USD) |
| `maxLoanAmount` | integer | — | Maximum `initialApprovalAmount` (USD) |
| `city` | string | — | Case-insensitive substring on `borrowerCity` |
| `maxResults` | integer | `100` | Hard cap (1–10,000) |
| `enrichWithGoogle` | boolean | `false` | Per-borrower web enrichment (website / LinkedIn / emails) |
| `enrichLimit` | integer | `50` | Max borrowers to enrich (1–1,000) |
| `proxyConfig` | proxy | residential | Used for enrichment only |

***

### 💰 Pricing & cost

Pay-per-event:

- **Per borrower returned** — small fee, scales linearly
- **Per enriched borrower** — only when `enrichWithGoogle: true`, capped by `enrichLimit`

A typical run pulling 500 construction companies in Texas with no enrichment costs less than a coffee. Adding enrichment to 200 of them stays well under $5 per run.

Failed requests, rate-limit backoffs and dataset-side empty pages are not charged.

***

### 🧭 Quick reference — popular NAICS prefixes

| NAICS prefix | Industry |
| --- | --- |
| `11` | Agriculture, Forestry, Fishing |
| `21` | Mining |
| `22` | Utilities |
| `23` | Construction |
| `31`–`33` | Manufacturing |
| `42` | Wholesale Trade |
| `44`–`45` | Retail Trade |
| `48`–`49` | Transportation and Warehousing |
| `51` | Information / Tech / Media |
| `52` | Finance and Insurance |
| `53` | Real Estate / Rental / Leasing |
| `54` | Professional, Scientific, Technical Services |
| `56` | Administrative / Support / Waste Management |
| `61` | Educational Services |
| `62` | Health Care and Social Assistance |
| `71` | Arts, Entertainment, Recreation |
| `72` | Accommodation and Food Services |
| `81` | Other Services (incl. repair, personal services) |

Use the 2-digit prefix for broad sweeps (`23` for all construction), or a longer prefix for finer cuts (`238` specialty trade contractors).

***

### ❓ Frequently asked questions

**Is this data real and verified?**
Yes. Every record comes from the SBA's own FOIA release of the Paycheck Protection Program. The dataset is the legal source of truth — banks and courts use it.

**Is the PPP loan database free?**
The raw SBA dataset is public-domain and free. This actor charges only for the work of filtering, enriching and delivering it as a clean stream you can use in a CRM or outbound tool.

**Is the borrower's address always present?**
For loans over $150K (`large` tier) — yes. For loans $150K and under (`small` tier) the SBA published city + state + ZIP only; the precise street address is redacted.

**Why is state required for the small tier?**
The small-tier dataset is ~10M records split across 12 huge CSV files. Filtering by state lets the actor download only the slice you need.

**Can I get phone numbers?**
The SBA does not publish phone numbers. The enrichment step will pull a phone if the borrower's public website lists one (most do).

**Can I get borrower emails?**
The SBA does not publish emails. The enrichment step pulls any emails the borrower has published on their own website, LinkedIn page, Facebook page or contact form.

**How fresh is the data?**
The SBA dataset is a snapshot of the closed-out PPP program (2020–2021 loans, with forgiveness data through 2023). The actor reads the latest published snapshot from `data.sba.gov`.

**Can I get PPP loan lookup by name free?**
Yes — set `companyNameContains` to a fragment of the borrower name. The base lookup is the same data ProPublica's PPP search uses, just exposed as an API.

**Can I get a PPP loan list by zip code?**
Set `state` + `city`. The actor returns `borrowerZip` per record, so you can post-filter by ZIP in the Dataset view.

**Does this scraper work for EIDL loans (the other COVID program)?**
Currently no — this actor focuses on PPP. EIDL has a separate dataset and a separate actor is on the roadmap.

**Is this legal to use for outbound sales?**
The dataset is public-domain. Outbound sales must still follow CAN-SPAM, TCPA, and state law. The actor does not generate or send any messages.

**Can I run this on a schedule?**
Yes — Apify Schedules supports cron expressions. Common pattern: weekly run with a fresh industry + state slice to keep your CRM warm.

**Does enrichment really find websites and emails?**
For most SMBs with a public web presence, yes. For solo proprietors with no website, enrichment returns `null`. The actor is honest about misses.

**How does this compare to Apollo / ZoomInfo?**
Apollo and ZoomInfo are great for tech companies and enterprise. For US Main-Street SMBs (plumbers, restaurants, contractors, retailers) the SBA PPP dataset is denser, cheaper, and FOIA-clean.

**Can I integrate this with Claude, Cursor, or other AI agents?**
Yes — call the actor via the Apify API from your agent, or wrap it with Apify's MCP server.

***

### 🔗 Other actors by makework36

Useful companions for B2B and SMB lead-gen workflows:

- [FMCSA Trucking API](https://apify.com/makework36/fmcsa-trucking-api) — every US trucking carrier with DOT/MC, address, fleet size + enrichment
- [NPI Registry API](https://apify.com/makework36/npi-registry-api) — every US healthcare provider with NPI, taxonomy, address + enrichment
- [Website Email & Contact Finder](https://apify.com/makework36/email-finder-scraper) — extract emails from any URL
- [Google Maps Scraper](https://apify.com/makework36/google-maps-scraper-full) — local business data + emails + phones at $1/1K
- [Facebook Ad Library Scraper](https://apify.com/makework36/facebook-adlib-scraper) — competitor ad intelligence
- [IndiaMART Suppliers Scraper](https://apify.com/makework36/indiamart-suppliers-scraper) — B2B suppliers with verified phones + GST
- [Reddit SaaS Leads Scraper](https://apify.com/makework36/reddit-leads-saas) — find startup pain points and early adopters
- [Reddit Real Estate Leads](https://apify.com/makework36/reddit-realestate-scraper) — buyers, investors, landlords
- [Shopify Products Scraper](https://apify.com/makework36/shopify-products-scraper) — any Shopify store catalog
- [Trustpilot Scraper API](https://apify.com/makework36/trustpilot-reviews-scraper) — reviews + ratings
- [Substack Scraper](https://apify.com/makework36/substack-scraper) — newsletter posts and authors
- [Lovable Sites Scraper](https://apify.com/makework36/lovable-sites-scraper) — discover `.lovable.app` apps

***

### 📝 Changelog

- **v0.1** — Initial release. Three tiers (large / small / all), 30+ fields per borrower, optional Google enrichment, all 50 states.

***

### 🛠️ Support

Missing a field, hit a bug, need EIDL? Open an issue or message me directly from the Apify Console. Fast turnaround for paying users.

# Actor input Schema

## `tier` (type: `string`):

Which SBA dataset to search. 'large' = loans over $150K (~1M records, fast). 'small' = loans up to $150K (~10M records, slower — uses 12 split files).

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

Filter by borrower state. Required for `small` and `all` tiers (otherwise the dataset is huge).

## `companyNameContains` (type: `string`):

Case-insensitive substring match on BorrowerName.

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

Filter by NAICS industry code (prefix match). E.g. '23' = Construction, '54' = Professional services.

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

Filter by business legal type, e.g. 'Corporation', 'LLC', 'Sole Proprietorship'.

## `minLoanAmount` (type: `integer`):

Minimum InitialApprovalAmount.

## `maxLoanAmount` (type: `integer`):

Maximum InitialApprovalAmount.

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

Case-insensitive substring match on BorrowerCity.

## `maxResults` (type: `integer`):

Hard cap on records to return.

## `enrichWithGoogle` (type: `boolean`):

For each borrower, find website, LinkedIn, Facebook page, and secondary emails using an internal SERP fetcher. No API key required.

## `enrichLimit` (type: `integer`):

Max number of borrowers to enrich.

## `proxyConfig` (type: `object`):

Apify proxy. Only used during enrichment, not for the SBA CSV download.

## Actor input object example

```json
{
  "tier": "large",
  "maxResults": 100,
  "enrichWithGoogle": false,
  "enrichLimit": 50,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `loans` (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("makework36/ppp-loan-finder").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("makework36/ppp-loan-finder").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 makework36/ppp-loan-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PPP Loan Finder API - 11M US SMBs + Enrichment",
        "description": "Search 11M+ US small businesses that received COVID PPP loans (SBA data). Filter by state, name, industry, amount. Optional website & email enrichment.",
        "version": "1.0",
        "x-build-id": "h5ntgtdEx6Tbu5Ucc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/makework36~ppp-loan-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-makework36-ppp-loan-finder",
                "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/makework36~ppp-loan-finder/runs": {
            "post": {
                "operationId": "runs-sync-makework36-ppp-loan-finder",
                "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/makework36~ppp-loan-finder/run-sync": {
            "post": {
                "operationId": "run-sync-makework36-ppp-loan-finder",
                "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": {
                    "tier": {
                        "title": "Loan size tier",
                        "enum": [
                            "large",
                            "small",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which SBA dataset to search. 'large' = loans over $150K (~1M records, fast). 'small' = loans up to $150K (~10M records, slower — uses 12 split files).",
                        "default": "large"
                    },
                    "state": {
                        "title": "State (2-letter code)",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Filter by borrower state. Required for `small` and `all` tiers (otherwise the dataset is huge)."
                    },
                    "companyNameContains": {
                        "title": "Company name contains",
                        "type": "string",
                        "description": "Case-insensitive substring match on BorrowerName."
                    },
                    "naicsCode": {
                        "title": "NAICS code prefix",
                        "type": "string",
                        "description": "Filter by NAICS industry code (prefix match). E.g. '23' = Construction, '54' = Professional services."
                    },
                    "businessType": {
                        "title": "Business type",
                        "type": "string",
                        "description": "Filter by business legal type, e.g. 'Corporation', 'LLC', 'Sole Proprietorship'."
                    },
                    "minLoanAmount": {
                        "title": "Min loan amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum InitialApprovalAmount."
                    },
                    "maxLoanAmount": {
                        "title": "Max loan amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum InitialApprovalAmount."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Case-insensitive substring match on BorrowerCity."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on records to return.",
                        "default": 100
                    },
                    "enrichWithGoogle": {
                        "title": "Enrich with web search",
                        "type": "boolean",
                        "description": "For each borrower, find website, LinkedIn, Facebook page, and secondary emails using an internal SERP fetcher. No API key required.",
                        "default": false
                    },
                    "enrichLimit": {
                        "title": "Enrich limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Max number of borrowers to enrich.",
                        "default": 50
                    },
                    "proxyConfig": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy. Only used during enrichment, not for the SBA CSV download.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
