# SBA 7(a) & 504 Guaranteed Loan Approvals (`usta/sba-guaranteed-loan-approvals`) Actor

Businesses that just got an SBA-guaranteed 7(a) or 504 loan approved: name, city/state, lender, amount, date, and industry. Read live from SBA's own public FOIA extract.

- **URL**: https://apify.com/usta/sba-guaranteed-loan-approvals.md
- **Developed by:** [US Tech Automations](https://apify.com/usta) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 result rows

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Find Businesses That Just Got an SBA-Guaranteed Loan

**For SBA loan brokers and bank business-development reps:** get businesses that just had an SBA-guaranteed loan approved as one row each, with SBA's six separate FOIA files already merged.

Get one row for every business that just had an SBA-guaranteed 7(a) or 504
loan approved: who they are, where they are, who lent to them, how much, and
what industry they're in.

### Introduction

Every 7(a) working-capital loan and every 504 fixed-asset loan the U.S. Small
Business Administration guarantees is disclosed at the individual-loan level
in SBA's own public FOIA extract — because a lender only closes one of these
loans when a business is actively investing or expanding, that disclosure is
also one of the clearest "who is spending money right now" signals a small
business can produce. This Actor reads SBA's own FOIA files live on every
run and returns the loans approved in your chosen window: no scraping of a
third-party mirror, no stale export.

### Tutorial

1. Set **Program** to `7(a)`, `504`, or `Both`.
2. Set **Days back** to how far behind SBA's own newest published record to
   look. SBA updates this file quarterly, so "days back" counts from the
   newest date SBA has actually published, not from today — see
   Limitations below.
3. Set **Maximum rows** to your spend cap. Every row bills, so this is also
   the most a single run can cost.
4. Optionally set **Borrower state** (e.g. `TX`) to one state, **NAICS code
   prefix** (e.g. `72` for accommodation and food service) to one industry,
   and/or **Minimum loan amount** to only see loans at or above a size worth
   your time.
5. Click **Start**. Results land in the dataset.

### Pricing

**$0.004 per row. No start fee.**

A row here is a named business, its lender, and a specific dollar amount and
date — not just "a filing exists." A run that returns 200 qualifying loans
costs $0.80. A run that finds none because your filters are narrow costs
nothing.

**Maximum rows** is the spend cap: the run cannot cost more than that number
multiplied by $0.004, whatever the window holds.

### Input and output examples

Input:

```json
{"program": "both", "daysBack": 45, "maxItems": 25, "state": "TX"}
```

Output (one row, from a live run on 2026-09-15):

```json
{
  "program": "7(a)",
  "sba_location_id": "0455644",
  "borrower_name": "Gallomar, LLC",
  "borrower_street": "297 W. ROUND GROVE RD",
  "borrower_city": "LEWISVILLE",
  "borrower_state": "TX",
  "borrower_zip": "75067",
  "lender_name": "Live Oak Banking Company",
  "lender_city": "WILMINGTON",
  "lender_state": "NC",
  "third_party_lender_name": null,
  "loan_amount_usd": 175000.0,
  "sba_guaranteed_amount_usd": 131250.0,
  "third_party_dollars_usd": null,
  "approval_date": "2026-06-30",
  "approval_fiscal_year": "2026",
  "first_disbursement_date": null,
  "term_months": 120.0,
  "naics_code": "811111",
  "naics_description": "General Automotive Repair",
  "franchise_name": "Midas",
  "project_county": "DENTON",
  "project_state": "TX",
  "business_type": "CORPORATION",
  "business_age": "Existing or more than 2 years old",
  "loan_status": "COMMIT",
  "jobs_supported": 7.0,
  "source_url": "https://data.sba.gov/sites/default/files/uploaded_resources/FOIA_7a_FY2020_Present_asof_260630.csv",
  "fetched_at": "2026-09-15T17:02:24Z"
}
```

Every field in a row:

| Field | What it holds |
|---|---|
| `program` | `7(a)` or `504` |
| `sba_location_id` | SBA's own identifier for this loan record |
| `borrower_name` / `borrower_street` / `borrower_city` / `borrower_state` / `borrower_zip` | The business that received the loan, as SBA discloses it |
| `lender_name` / `lender_city` / `lender_state` | The bank (7(a)) or Certified Development Company (504) that made or packaged the loan |
| `third_party_lender_name` | On a 504 loan only: the bank providing the first-mortgage portion alongside the CDC debenture. Null on 7(a) |
| `loan_amount_usd` | Total approved loan amount |
| `sba_guaranteed_amount_usd` | On a 7(a) loan only: the portion SBA guarantees. Null on 504 |
| `third_party_dollars_usd` | On a 504 loan only: the participating lender's dollar amount. Null on 7(a) |
| `approval_date` / `approval_fiscal_year` | When SBA approved the loan |
| `first_disbursement_date` | When funds were first disbursed; often blank for a just-approved loan that hasn't funded yet |
| `term_months` | Loan term |
| `naics_code` / `naics_description` | The borrower's industry |
| `franchise_name` | Franchise brand, when the loan record names one |
| `project_county` / `project_state` | Where the financed project is located |
| `business_type` / `business_age` | How SBA classifies the borrower |
| `loan_status` | SBA's current status code for the loan (e.g. `COMMIT`, `PIF`, `CHGOFF`) |
| `jobs_supported` | Jobs the lender reported the loan supports |
| `source_url` | The exact SBA CSV file this row was read from |
| `fetched_at` | When this run read SBA's site, in UTC |

### Recommendations

Run weekly with **Days back** set to 90 to reliably cover SBA's quarterly
publishing cycle without missing a batch, and use **Minimum loan amount** to
focus on loans large enough to be worth a call — a $5,000 SBA Express line and
a $3.2 million 504 debenture are very different prospects.

### Limitations

**Not same-day.** SBA republishes this file on its own quarterly schedule.
The newest row available as of 2026-09-15 was dated 2026-06-30 — about an
11-week lag. **Days back** is therefore counted from the newest date SBA has
actually published, not from today, so a small window still returns rows
instead of silently coming back empty between SBA's updates.

**Recently committed, not always funded.** Many rows carry `loan_status:
"COMMIT"` with a blank `first_disbursement_date` — SBA has approved the
guarantee, but the borrower may not have drawn funds yet. That is still a
real, dated approval event; it is not the same as confirming the money has
moved.

**One record source, not per-loan pages.** SBA publishes this as a bulk file
rather than one web page per loan, so `source_url` names the exact file this
row came from rather than a unique page for that specific loan. `sba_location_id`
is SBA's own identifier for the record if you need to reference it precisely.

**Only what SBA states.** No amount is estimated and no field is inferred; a
blank field in SBA's file is returned as `null`.

### FAQ

**Where does the data come from?**
SBA's own open-data site, `data.sba.gov`, which publishes the same loan-level
FOIA extract it releases in response to Freedom of Information Act requests.

**Does it need an API key or a login?**
No. Nothing here requires an account, key, or registration of any kind.

**Why did I get fewer rows than Maximum rows?**
Either your window and filters matched fewer loans than your cap, or (rarely)
this Actor's per-run data-fetch limit was reached before your filters were
fully satisfied — check `OUTPUT.warnings`.

**What happens if SBA's site is down?**
The run pushes no rows, costs nothing, and writes a status of `UNKNOWN` with
the error to `OUTPUT`. It never fills the gap with made-up rows.

**Is there support?**
Issues can be raised through the Apify Store issues tab for this actor. No
response time is promised.

### Refunds and support

Refunds: if a run returns zero rows for a valid input, email operations@ustechautomations.com within 7 days and we refund that run. Support: same address, replies within 2 business days.

# Actor input Schema

## `program` (type: `string`):

Which SBA loan program to read. "both" combines 7(a) and 504.

## `daysBack` (type: `integer`):

How many days before the newest approval SBA has published to include. Counted from SBA's own newest record, not from today, because this file is only updated quarterly and typically lags 1-3 months behind the calendar date.

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

Hard cap on the number of loan rows this run produces, and therefore on what it can cost. Every row bills at the listed price from row one; there is no start fee.

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

Restrict to borrowers in one 2-letter US state/territory, e.g. "TX". Leave empty for every state.

## `naicsPrefix` (type: `string`):

Restrict to one industry by NAICS code prefix, e.g. "72" for accommodation and food service. Leave empty for every industry.

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

Only include loans at or above this total approved amount. Leave empty for every amount.

## Actor input object example

```json
{
  "program": "both",
  "daysBack": 45,
  "maxItems": 100
}
```

# Actor output Schema

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

No description

## `report` (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 = {
    "program": "both",
    "daysBack": 45,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("usta/sba-guaranteed-loan-approvals").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 = {
    "program": "both",
    "daysBack": 45,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("usta/sba-guaranteed-loan-approvals").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 '{
  "program": "both",
  "daysBack": 45,
  "maxItems": 100
}' |
apify call usta/sba-guaranteed-loan-approvals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,usta/sba-guaranteed-loan-approvals"
        }
    }
}
```

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/SHnawNejfP3qxgRfg/builds/bBoml4vIqnBiVTw2w/openapi.json