Disclosure: I'm Ben, and I built the Apify Actor mentioned later in this post. I charge per result for it. The tutorial part needs only Python and the free Grants.gov API.

Every federal grant opportunity (NOFO) is posted on Grants.gov, and Grants.gov has a public JSON API with no key. Hardly anyone uses it directly, partly because the useful parts (award ceiling, total funding, eligibility, agency contact) aren't in the search results. Here's how to get them, and the quirks I hit.

The two endpoints

• POST https://api.grants.gov/v1/api/search2 returns matching opportunities: id, number, title, agency, status, open and close dates. Up to rows per page, with startRecordNum for paging.
• POST https://api.grants.gov/v1/api/fetchOpportunity returns one opportunity's full detail: the synopsis with award ceiling and floor, estimated total funding, expected awards, cost sharing, eligible applicant types, Assistance Listings (CFDA) and the contact.

Step 1: Search, then fetch details

This ran as-is on 25 Oct 2026:

import requests
s = requests.post("https://api.grants.gov/v1/api/search2", json={
    "keyword": "artificial intelligence", "oppStatuses": "forecasted|posted", "rows": 3}, timeout=30).json()
print(s["data"]["hitCount"], "matches")
for hit in s["data"]["oppHits"]:
    d = requests.post("https://api.grants.gov/v1/api/fetchOpportunity",
                      json={"opportunityId": int(hit["id"])}, timeout=30).json()["data"]
    syn = d.get("synopsis") or {}
    print(hit["number"], hit["closeDate"] or "-", syn.get("awardCeiling"), syn.get("agencyContactEmail"))

Output (I've trimmed one individual's email):

167 matches
PD-19-127Y 02/10/2027 none grantsgovsupport@nsf.gov
W519TC-25-S-0001 - None None
G27AS00079 11/14/2026 150000 <agency contact>

Step 2: Filter by who can apply

This is the filter that matters most for nonprofits, universities and small businesses. Grants.gov tags each opportunity with eligible applicant codes, and search2 accepts them pipe-separated in eligibilities. A few: 12 = 501(c)(3) nonprofits, 13 = nonprofits without 501(c)(3), 20 = private institutions of higher education, 06 = public and state-controlled institutions of higher education, 23 = small businesses, 25 = others.

s = requests.post("https://api.grants.gov/v1/api/search2", json={
    "oppStatuses": "posted", "eligibilities": "12", "rows": 3}, timeout=30).json()["data"]
print(s["hitCount"])  # 440 on 25 Oct 2026

So on that day, 440 posted opportunities accepted 501(c)(3) applicants.

Step 3: The quirks

• Inconsistent types. awardCeiling came back as the string "none" for the NSF program and as a number for the USGS one. A forecasted DoD notice had no synopsis at all (it lives in a different forecast block). Parse defensively and normalise to null.
• US dates. closeDate is MM/DD/YYYY, and blank for forecasts and rolling programs. Convert before sorting by "closing soon", or 01/07/2028 sorts before 11/17/2026.
• Counts move daily. My keyword search had 171 matches on 18 Oct and 167 on 25 Oct. Opportunities close, and new ones are posted. Store the opportunity id and diff, rather than trusting counts.
• One detail call per result. Search is cheap, but anything useful needs fetchOpportunity. For 400+ results that's 400+ requests. Be gentle and cache.
• Contacts are often individuals. The agency contact is sometimes a shared inbox, sometimes a named program officer. Use it to ask about the program, not as a mailing list.

Step 4: Or use the packaged version

I packaged this as an Apify Actor, Grants.gov Scraper – Federal & Nonprofit Grants Finder. It runs the search, fetches every detail, normalises the types and dates, and returns one clean row per opportunity. It also adds daysUntilClose, and "posted in the last N days" / "closing within N days" filters for alerts.

Run-ready link: open it in Apify Console with an example input already filled in ({"keyword": "artificial intelligence", "maxItems": 20}). Click Start, or change the input first.

The pre-filled input (keyword artificial intelligence, forecasted + posted, 20 results) ran on 18 Oct 2026 in about 6 seconds and saved 20 of 171 matches:

The nonprofit version:

{ "statuses": ["posted"], "eligibilities": ["12"], "sortBy": "closingSoon", "maxItems": 10 }

That ran on 19 Oct 2026 and saved 10 of 443 matching opportunities. One was HRSA-27-005, the FY2027 Health Center Service Area Competition, with an award ceiling of $10,116,100, a floor of $650,000, $267,773,700 total, 63 expected awards, and daysUntilClose: 0. Sorting by closing date surfaces exactly the ones you're about to miss.

Each row has: id, number, title, agency, status, open and close dates, days left, CFDA numbers, award ceiling and floor, estimated total funding, expected awards, cost sharing, funding instruments, categories, eligible applicants, description, contact and the grants.gov link.

As a grant alert

Schedule a weekly run with "posted in the last 7 days", your eligibility codes and keywords, and push the new rows to email, Slack or a sheet. That replaces scanning the Grants.gov site by hand.

Limits, honestly

• Federal only. Grants.gov covers federal opportunities. Foundation, corporate and most state grants aren't there.
• It returns what Grants.gov publishes. If an agency leaves the ceiling or funding blank, so does the row. Forecasts usually have no deadline yet.
• Not a full NOFO. Eligibility rules, page limits and review criteria are in the attached documents, which you'll still need to read.
• Partial results. If Grants.gov errors partway through a large run, the Actor keeps what it saved and stops instead of failing the whole run.
• Not affiliated with Grants.gov.

What it costs

$0.003 per opportunity saved ($3 per 1,000), no start fee, and it stops at your maximum cost per run. The 20-result test was 6 cents. If you only need one search, the Python above is free and works fine.

If you look for grants regularly: what do you filter on, and what's missing from Grants.gov's own search? I'd like to know what to add next, so tell me in the comments.

Disclosure: I'm Ben, and I built the Apify Actor mentioned later in this post. I charge per result for it. Everything in the tutorial part works with free tools too.

If you sell to dentists, clinics, chiropractors or therapists, or you need to verify a list of providers, the best free source in the US is the NPI Registry (NPPES), run by CMS. Every HIPAA-covered provider has a National Provider Identifier, about 8 million of them, and the registry has a public API with no key.

Each record has the NPI, name, credential, taxonomies (specialties), license, practice and mailing addresses with phone and fax, the date the NPI was issued, and for organizations the authorized official (often the owner or CEO) with title and phone.

What it doesn't have: email addresses. Plan around that from the start.

If you need everything, CMS also publishes the full NPPES data dissemination file (monthly, plus weekly updates). It's free and complete, and it's a very large CSV with hundreds of columns. For targeted lists, the API is easier.

Step 1: Query the API

https://npiregistry.cms.hhs.gov/api/?version=2.1&taxonomy_description=Dentist&city=San Diego&state=CA&limit=200

limit is at most 200, and you page with skip. Here's a pager that also keeps only providers whose primary taxonomy is a dentist one. It ran as-is on 25 Oct 2026:

import requests
def npi(**q):
    out, skip = [], 0
    while True:
        r = requests.get("https://npiregistry.cms.hhs.gov/api/", params={
            "version": "2.1", "limit": 200, "skip": skip, **q}, timeout=30).json()
        batch = r.get("results", [])
        out += batch
        if len(batch) < 200 or skip >= 1000:   # skip is capped at 1000 -> max 1,200 per query
            return out
        skip += 200
rows = npi(taxonomy_description="Dentist", city="San Diego", state="CA")
print(len(rows))
primary = [r for r in rows if any(t["primary"] and "Dent" in t["desc"] for t in r["taxonomies"])]
print(len(primary), "with a dentist taxonomy as primary")

Output:

1200
1193 with a dentist taxonomy as primary

Exactly 1,200 is suspicious, and it should be.

Step 2: The pitfalls

• Every query stops at 1,200 results. skip is capped at 1000, and a page holds 200. Worse, it fails silently: I asked for skip=1000, skip=1200 and skip=2000 on a California dentist search, and all three returned the same page. If you just keep paging, you collect duplicates and think you're done. To get a whole city or state, split the search (by city, or by ZIP prefix, and for a state by both) until each piece is under 1,200, then dedupe on NPI.
• Specialty matches any taxonomy. A provider with Dentist as a secondary taxonomy still matches. Above, 7 of 1,200 didn't have a dentist taxonomy as primary. For strict lists, check the primary flag.
• Two addresses. Each record has a MAILING and a LOCATION address, and in the record I checked the mailing address came first in the list. Use address_purpose, not position. City and state searches can match either one, so a "San Diego" search can include providers who only mail from there.
• "New practices" isn't a query parameter. The API can't filter on the NPI issue date (enumeration_date). To find newly enumerated providers, you pull and filter client-side.
• Self-reported data. Phones and fax numbers are what providers entered, and some records haven't been updated in years. last_updated tells you how stale a record is.

Step 3: Or use the packaged version

I packaged this as an Apify Actor, NPI Registry Scraper – NPPES Healthcare Provider Leads. The main thing it adds is auto-splitting: large searches are split by state and ZIP prefix, so you can pull a whole state past the 1,200 cap. When it splits by state, it keeps providers whose practice location is in that state.

Run-ready link: open it in Apify Console with an example input already filled in ({"specialties": ["Dentist"], "states": ["CA"], "cities": ["San Diego, CA"], "maxItems": 50}). Click Start, or change the input first.

{
  "specialties": ["Dentist"],
  "states": ["CA"],
  "cities": ["San Diego, CA"],
  "maxItems": 50
}

Other inputs: individual vs organization, ZIPs, names, a list of NPIs to verify, and filters for NPI issued after, record updated after, only with phone, and primary specialty must match. Output is deduplicated, with formatted phones and ZIPs and separate practice and mailing addresses.

That input ran on 18 Oct 2026 in about 18 seconds and returned 50 providers. Some rows:

Organization rows are the useful ones for B2B. For A.S. KIM DDS, INC., the row has the authorized official (a DDS, title "CEO") with a phone, the practice phone, license number, other names (DBA "VILLAGE HILLCREST DENTAL"), and the count of additional practice locations.

A bigger real example from my testing: all individual chiropractors in California with a phone came to 3,000 providers in about 3 minutes.

A monthly "new practices" list

Set NPI issued after (enumeratedAfter) to 90 days ago, pick your specialties and states, and schedule it monthly. New clinicians and new group practices show up as they get their NPIs.

Limits, honestly

• No emails. NPPES doesn't publish them. You get practice phone and fax, the mailing address and, for organizations, the authorized official. If you need an email, you'll need the practice's website.
• Self-reported and sometimes stale.
• NPI holders only. It covers HIPAA-covered providers, not every wellness or cosmetic business.
• Not affiliated with CMS or HHS.

What it costs

$0.001 per provider ($1 per 1,000), no start fee. Duplicates and filtered-out records are free, and runs stop at your "maximum cost per run". The 50-provider test was 5 cents. The API and the full CMS file are free.

Play fair

Practice phones are business lines, but authorized officials are people. TCPA rules apply to calls and texts, CAN-SPAM to email, and some providers will rightly be annoyed by cold outreach. Be relevant and honour opt-outs.

Do you work with NPPES data? I'd like to hear how you deal with stale records, so tell me in the comments.

Disclosure: I'm Ben, and I built the Apify Actor mentioned later in this post. I charge per result for it. The tutorial part uses only free public data.

Freight insurance agents, factoring companies, ELD and fuel-card sellers, and brokers looking for capacity all need the same thing: a list of trucking companies with a phone number and fleet size. People pay for those lists, but the source behind most of them is free. Every US interstate carrier files an MCS-150 with FMCSA, and US DOT publishes the result as open data, refreshed daily.

Here's how to query it yourself, and what tripped me up.

The datasets

All on data.transportation.gov (Socrata), no key needed for light use:

• Company Census File (az4n-8mr2): one row per USDOT number, with legal name, address, phone, email (if filed), power units, drivers, cargo, operation type and status.
• L&I "Carrier – All With History" (6eyk-hxee): MC dockets, authority and insurance.
• L&I "AuthHist – All With History" (9mw4-x3tu): authority grants, revocations and reinstatements.

Step 1: A SoQL query

Small Dallas carriers (5–50 power units), active, with an email on file:

curl -s -G "https://data.transportation.gov/resource/az4n-8mr2.json" \
  --data-urlencode "\$select=dot_number,legal_name,phone,email_address,power_units,total_drivers" \
  --data-urlencode "\$where=phy_state='TX' AND phy_city='DALLAS' AND status_code='A' AND power_units ::number BETWEEN 5 AND 50 AND email_address IS NOT NULL" \
  --data-urlencode "\$order=dot_number" \
  --data-urlencode "\$limit=5"

Run on 25 Oct 2026 (emails left out here):

Step 2: The pitfalls

Numbers are stored as text. My first version used power_units BETWEEN 5 AND 50 and Socrata rejected it with a type mismatch. You need the ::number cast. Without a cast, a comparison like > on a text column runs as a string comparison, so "9" > "50" is true.

Cities are free text, uppercase. phy_city='DALLAS' works, but a filer who typed a suburb or a typo won't match. For full coverage, filter by ZIP prefix (phy_zip like '752%') as well as city.

"Active" isn't one thing. status_code='A' is the USDOT status. Whether a company can legally haul freight for hire is a separate question, the operating authority (MC number), and that lives in the L&I datasets. The census also has private fleets: Texas Instruments and a lumber company are in my list because they run their own trucks. If you're selling to for-hire carriers, filter on the classification and join authority status.

The join is the slow part. Authority history is per docket, with multiple grant, revocation and reinstatement rows. You have to fetch the dockets for your candidate USDOT numbers and work out the current state. My Actor's test run (below) used the same city and fleet filters plus "active authority", and it left out Bishop International and Davis-Hawn Lumber, which my raw query includes. So the census alone and census + authority give different lists.

Formatting. Phones come back as raw digits, and names like SERVICEINC are as filed. Email exists only when the company put one on its MCS-150.

Step 3: Or use the packaged version

I packaged this as an Apify Actor, FMCSA Carrier Leads – Trucking Companies & Freight Brokers List. It builds the SoQL for you, joins the census with both L&I datasets, and returns one clean row per company.

Run-ready link: open it in Apify Console with an example input already filled in ({"states": ["TX"], "cities": ["Dallas, TX"], "maxItems": 25}). Click Start, or change the input first.

{"states":["TX"],"cities":["Dallas, TX"],"entityType":"carrier","minPowerUnits":5,"maxPowerUnits":50,"authorityStatus":"active","requireEmail":true,"maxItems":10}

Filters: states, cities, ZIP prefixes, USDOT or MC numbers, name contains, entity type (carrier, broker, both, freight forwarder, shipper), operation type, classification (for-hire, private…), USDOT status, authority status, power units and driver ranges, cargo types, hazmat, safety rating, USDOT add date, and "only with email".

That input ran on Apify on 22 Oct 2026 and returned 10 carriers. A few rows (emails omitted):

Each record has formatted phones, the full address, company officers, fleet and driver counts, MCS-150 mileage, cargo types, safety rating and review dates, common/contract/broker authority, pending and revocation flags, BIPD insurance on file vs required, and the authority history. For Ecobat, the history shows the authority revoked on 2022-12-19 and reinstated on 2022-12-23, the kind of detail that matters if you're vetting. Every record also links to the SAFER snapshot. A SUMMARY record shows records scanned, API calls and the exact SoQL filter used, so you can reproduce it.

Recipes

• New carriers for insurance/factoring: USDOT added in the last 90 days, for-hire, 1–10 power units, your states, with email. Schedule it weekly.
• Capacity sourcing: cargo type "Refrigerated Food", 5–50 power units, Satisfactory rating, active authority.
• Broker list: entity type broker, active broker authority, by state.

Limits, honestly

• It's only as good as the MCS-150. Small carriers often file infrequently, so phones, emails and fleet sizes can be stale. Each record has mcs150Date so you can judge.
• Email is often missing. "Only with email" shrinks lists a lot.
• The authority filter is slow because it runs after the census query. Narrow by state, city or fleet size for big searches.
• No inspection or crash detail (SMS/CSA scores). Only the safety rating and review dates from the census.
• Compliance is on you. It's public government data, but TCPA and CAN-SPAM still apply when you call or email.

What it costs

$0.002 per company saved ($2 per 1,000). No start fee, and the run stops cleanly at your maximum charge. The 10-row test cost 2 cents. For a one-off pull of one city, the curl above is free.

If you work in freight: what do you actually filter on when you build a carrier list? Fleet size, cargo, authority age? I'd like to know which filters matter in practice, so tell me in the comments.