Federal Contract Awards API

Search federal prime contract transactions by recipient UEI, PIID, agency, NAICS, or award type. Every base award and every modification is one row, sourced from the federal procurement system of record and normalized into a stable JSON envelope. Coverage today is FY2025 + FY2026 (October 2024 onward); the plan window is sized for 5 years so older fiscal years drop in as we backfill, without breaking your integration.

9M+ Prime contract transactions
8M+ Distinct contracts (PIIDs)
100K+ Unique recipients (UEI)
Daily Refresh cadence

The Problem

Federal prime contract data is the foundation under every other procurement question, but accessing it is fragmented across three systems that all return different shapes of the same answer.

FPDS is the official record. The interface is SOAP, the response is XML, and stitching together one company's contract history is a multi-day integration that you redo from scratch every time the schema shifts. USAspending exposes the same data through a modern REST interface, but its search endpoint returns null for NAICS, PIID, total obligation, and contract type. To populate those fields you re-fetch each award individually from a second endpoint, then merge. SAM.gov publishes the subset that becomes a public notice, which is roughly 10 to 30 percent of obligations depending on the agency. Subaward filings live in a fourth dataset entirely.

If you need contract activity to drive BD pipelines, recipient profiles, vendor risk scoring, or supply-chain analysis, you end up integrating all four data sources with different schemas, rate limits, and refresh cadences. This endpoint is the alternative: every federal prime contract transaction since October 2024 (FY2025) in one JSON shape, with stable identifiers, a documented field set, and a single auth header.

Is the FPDS.gov API still active?

Yes, but only through an Atom XML feed with a search-string query language. The website www.fpds.gov now 301-redirects, which leads many people to assume the API was shut down when the federal award systems consolidated into SAM.gov. It was not. The FPDS-NG Atom feed is still live: as of July 8, 2026, https://www.fpds.gov/ezsearch/FEEDS/ATOM returns HTTP 200 with real contract data.

What it is, and why developers reach for a wrapper:

Atom XML, not JSON. Each award is an <entry> of deeply nested, ns1:-namespaced fields (PIID, UEI, obligatedAmount, principalNAICSCode, productOrServiceCode, baseAndAllOptionsValue, and dozens more). To extract one company's history, you must parse the schema for each field.
A search-string query language, not parameters. You filter by packing a field-and-value string into q=, for example q=NAICS_CODE:541512 LAST_MOD_DATE:[2026/06/25,2026/06/26]. There is no API key; the real access requirement is knowing the field names and the date-bracket syntax.
It fails silently. A slightly-off query returns an empty <feed> with HTTP 200 and no error, so you debug without error feedback. We hit exactly this while verifying the feed for this page.

The live feed, verified 2026-07-08 (10 entries in a one-day window; one real award shown):

GET https://www.fpds.gov/ezsearch/FEEDS/ATOM?FEEDNAME=PUBLIC&templateName=1.5.3&q=LAST_MOD_DATE:[2026/06/25,2026/06/26]

# one <entry>, abbreviated from the ns1:-namespaced Atom XML:
#   PIID 0001 · ATKINS NORTH AMERICA, INC. · obligatedAmount 300000.00
#   principalNAICSCode 541611 · productOrServiceCode R408 · agency 6955

So how do you access FPDS data today? Three ways, in rising order of usability:

The FPDS-NG Atom feed above: free and official, but Atom XML with a query-string language and no JSON.
USAspending.gov's REST API: modern JSON, but its search endpoint returns null for NAICS, PIID, total obligation, and contract type, so you re-fetch each award from a second endpoint to fill them in.
A clean JSON API (this one): the same FPDS prime-contract records in a stable, named-field envelope with one Authorization header, documented parameters, and a daily refresh.

The rest of this page documents option 3.

Endpoints

Three endpoints cover this: contract search across prime transactions, one contract by PIID, and its full modification trail.

Filter-based search across prime contract transactions:

GET https://govconapi.com/api/v1/contracts/search

Single contract detail (latest transaction plus a roll-up across every transaction under this PIID):

GET https://govconapi.com/api/v1/contracts/{piid}

Full transaction history for one PIID, oldest action first:

GET https://govconapi.com/api/v1/contracts/{piid}/modifications

Query Parameters

Applies to /api/v1/contracts/search. At least one of uei, parent_uei, piid, parent_piid, agency, or naics is required. Unknown parameters return 400.

Parameter	Type	Description
uei	string (12)	Recipient Unique Entity Identifier. Exact match, case-insensitive.
parent_uei	string (12)	Recipient parent UEI. Use for corporate roll-up across subsidiaries.
piid	string	Procurement Instrument Identifier. Exact match, upper-cased server-side.
parent_piid	string	Parent award PIID (the indefinite delivery vehicle the order sits under).
agency	string	Awarding agency name substring, case-insensitive. `defense` matches every DoD sub-agency.
naics	string	Exactly 6 digits. Bad shape returns 400.
award_type_code	A \| B \| C \| D	FPDS prime contract types. A = BPA Call, B = Purchase Order, C = Delivery Order, D = Definitive Contract. Not a substantive filter on its own; combine with one of the above.
date_from	YYYY-MM-DD	Lower bound on `action_date`. Older dates are soft-clamped to the coverage floor and the clamp is surfaced in the response window block.
date_to	YYYY-MM-DD	Upper bound on `action_date`.
amount_min	number	Minimum `federal_action_obligation`. `0` is honored. Accepts `value_min` as an alias.
amount_max	number	Maximum `federal_action_obligation`. Accepts `value_max` as an alias.
sort_by	string	One of `action_date` (default), `federal_action_obligation`, `current_total_value_of_award`, `recipient_name`.
sort_order	asc \| desc	Default `desc`. Nulls sort last on descending, first on ascending.
limit	integer	Default 100. Up to 100 on the free trial, 1,000 on paid plans.
offset	integer	Pagination offset.
fields	string	`lean` (default, 26 fields), `expanded` (57 fields), `full` (every column), or a comma-separated explicit list.

Example Requests

Recent IT services contracts to one vendor under Defense:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/search?uei=CKV2L9GZKJK3&naics=541512&agency=defense&limit=50"

Definitive contracts (type D) over $1M in calendar year 2025:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/search?uei=CKV2L9GZKJK3&award_type_code=D&amount_min=1000000&date_from=2025-01-01&date_to=2025-12-31"

Every transaction under a corporate parent, lean projection:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/search?parent_uei=DJUCEANK2KP4&fields=lean&limit=250"

Single contract detail (latest action plus the obligation roll-up):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/W56JSR23F0062"

Full modification trail under one PIID, oldest first:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/W56JSR23F0062/modifications?limit=500"

Tight projection for high-volume polling:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/search?agency=defense&naics=541512&fields=award_id_piid,recipient_name,federal_action_obligation,action_date&limit=250"

Response Format

Search returns a data array, a pagination block, a filters_applied echo of the resolved filters, a window block describing the coverage horizon, and a _sources array naming where the data came from.

{"data": [
    {"award_id_piid":                "W56JSR23F0062",
     "parent_award_id_piid":         "W56JSR21D0001",
     "modification_number":          "P00093",
     "action_date":                  "2026-02-27",
     "action_type":                  "EXERCISE AN OPTION",
     "federal_action_obligation":    2250000.00,
     "current_total_value_of_award": 392556695.66,
     "award_type_code":              "C",
     "award_type":                   "DELIVERY ORDER",
     "awarding_agency_name":         "DEPT OF DEFENSE",
     "awarding_sub_agency_name":     "Department of the Army",
     "recipient_uei":                "CKV2L9GZKJK3",
     "recipient_name":               "DELOITTE CONSULTING LLP",
     "naics_code":                   "541512",
     "naics_description":            "COMPUTER SYSTEMS DESIGN SERVICES",
     /* 12 more lean fields */
    }
  ],
  "pagination": { "limit": 50, "offset": 0, "total": 2808, "total_is_estimate": false, "has_next": true },
  "filters_applied": { "uei": "CKV2L9GZKJK3", "sort_by": "action_date", "sort_order": "desc" },
  "window": { "plan_window_days": 1825, "earliest_searchable": "2024-10-01", "clamped": false },
  "_sources": ["usaspending_fpds"]
}

The detail endpoint returns a singular contract object plus a transaction_rollup sibling block that aggregates obligations, ceiling, distinct recipients, and action-date bounds across every transaction under that PIID. Pro responses also include a subaward_rollup sibling for subaward enrichment.

Field	Type	Notes
`award_id_piid`	string	Procurement Instrument Identifier. Primary lookup key.
`parent_award_id_piid`	string \| null	Parent vehicle (IDV) PIID when this is a delivery or task order.
`modification_number`	string	FPDS modification identifier. Base award is typically `0` or `P00000`; subsequent actions increment.
`action_date`	string (ISO date)	Date this FPDS transaction was recorded. Drives the search window.
`action_type`	string	Plain-text description of the action (e.g. `EXERCISE AN OPTION`, `SUPPLEMENTAL AGREEMENT FOR WORK WITHIN SCOPE`).
`federal_action_obligation`	number	Dollar amount obligated by this single action. Can be negative on deobligations.
`current_total_value_of_award`	number \| null	Cumulative authorized value of the contract including options that have been exercised. A ceiling, not a draw-down counter.
`potential_total_value_of_award`	number \| null	Ceiling including all unexercised options.
`award_type_code`	A \| B \| C \| D	FPDS prime contract type. A = BPA Call, B = Purchase Order, C = Delivery Order, D = Definitive Contract.
`awarding_agency_name`	string	Top-level awarding department.
`awarding_sub_agency_name`	string	Awarding sub-agency or component.
`recipient_uei`	string	Recipient Unique Entity Identifier.
`recipient_name`	string	Recipient legal name as published.
`recipient_parent_uei`	string \| null	Parent UEI when the recipient is part of a corporate group.
`recipient_state_code`	string \| null	Recipient state, 2 letters.
`naics_code`	string \| null	6-digit NAICS classification.
`naics_description`	string \| null	NAICS name.
`transaction_description`	string \| null	Free-text description of the work for this action.
`type_of_set_aside`	string \| null	Small business / SDVOSB / 8(a) / HUBZone classification, when applicable.
`usaspending_permalink`	string	USAspending UI link for cross-checking the same transaction.

For the wider 57-field expanded projection (funding agency, period of performance, place of performance, competition flags) and the 298-column full projection, pass ?fields=expanded or ?fields=full respectively.

Subaward Enrichment Pro

The detail endpoint /api/v1/contracts/{piid} returns a subaward_rollup sibling block on Pro keys, summarizing the FFATA subaward footprint flowing from this prime contract. The block carries the sub-vendor count, total subcontracted dollars, share of the prime obligation, distinct sub-vendor count, first and last subaward dates, plus the top 5 named sub-vendors with per-sub totals.

Within the FY2025+ coverage window the PIID join into the subaward layer is dense: roughly 88 percent of subaward filings match a prime contract row, and 98 percent of in-scope contracts that have subaward activity see a populated block. The corresponding join from SAM Award Notices into subawards covers under 1 percent of the same population, which is why subaward enrichment lives on this endpoint rather than on the SAM-notice surface.

{
  "contract": { /* 26 lean fields, latest transaction */ },
  "transaction_rollup": {
    "transaction_count":               52,
    "total_obligated":                  162360657.45,
    "max_current_total_value":          392556695.66,
    "max_potential_total_value":        504348015.85,
    "latest_current_total_value":       392556695.66,
    "latest_potential_total_value":     504348015.85,
    "first_action_date":                "2024-10-11",
    "latest_action_date":               "2026-02-27",
    "distinct_recipient_ueis":          1
  },
  "subaward_rollup": {
    "subaward_count":            13,
    "total_subcontracted":       11189001.99,
    "prime_award_amount_ffata":  183928533.71,
    "subcontract_share":         0.0608,
    "distinct_sub_vendors":      7,
    "first_subaward_date":       "2024-10-03",
    "last_subaward_date":        "2025-04-04",
    "top_subs": [ /* up to 5 named subs with per-sub totals */ ]
  },
  "_sources": ["usaspending_fpds", "usaspending_ffata"]
}

What this response shape means for a BD or due-diligence read. The example above is the live response for Deloitte's $392M Army task order under PIID W56JSR23F0062. The customer-actionable signals are visible in one call: transaction_count: 52 says the prime has cycled 52 mods over 16 months (active, well-managed contract). subcontract_share: 0.0608 says Deloitte keeps 94 percent of the work in-house (high incumbency moat for a recompete). max_potential_total_value exceeds latest_potential_total_value only when an earlier mod set a higher ceiling than the current one, which is a scope-reduction signal worth chasing in a recompete play. The top 5 named subs (omitted in the snippet for length) include the same federal IT shops bidding the same recompete cycle, plus often a research partner. None of this requires joining three datasets client-side. The detail call delivers it.

For the full subaward record set under a PIID, use /api/v1/subawards/search?piid={piid}. For vendor-wide subaward activity across every contract a recipient holds, use the UEI-keyed reverse lookup /api/v1/companies/{uei}/subawards.

Modification Trails

Federal contracts have one PIID and many transactions. The base award is one transaction; every option exercised, value added, partial termination, and administrative cleanup is another. /api/v1/contracts/{piid}/modifications returns the full ASC-ordered trail, oldest action first, so you can reconstruct what happened on a single contract over its life.

This endpoint is not date-windowed. When you ask for one PIID's history, you get the full history we carry, regardless of the coverage window that applies to search.

Walk every action on a contract in chronological order:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://govconapi.com/api/v1/contracts/W56JSR23F0062/modifications?limit=500"

Quirks and Edge Cases

Action date is not work date.

action_date is when the transaction was recorded in FPDS, which drives the search window. period_of_performance_start_date and period_of_performance_current_end_date describe when work actually happens. A modification recorded today can extend a contract whose work starts next year.

Obligation amounts can be negative.

Deobligations carry negative federal_action_obligation. To get net obligated dollars on a PIID, sum the field across all transactions (which is what transaction_rollup.total_obligated reports on the detail endpoint).

`current_total_value_of_award` is a ceiling, not a draw-down.

This is the cumulative authorized value of the contract including exercised options. It moves when the ceiling itself moves, not when work is delivered. To track money actually obligated, sum federal_action_obligation.

PIID is not unique across the executive branch.

Two agencies can independently assign the same PIID under different parent vehicles. Disambiguate with parent_award_id_piid alongside award_id_piid, or use contract_award_unique_key which is globally unique.

DUNS columns are present but largely null post-2022.

When SAM retired DUNS for UEI in April 2022, federal systems stopped collecting new DUNS values. Records that started before then carry both; FY2025+ records carry UEI only.

Source values pass through unchanged.

Occasionally the upstream record carries a corrupt action_date (a year of 9202 or 1921) or an implausible obligation amount. These are agency-level reporting errors. We surface them as recorded rather than silently fixing them, so you stay aligned with the system of record.

Unknown query parameters return 400.

A typo in a filter name returns a 400 with the list of valid parameters rather than silently dropping the filter. Same gate prevents accidental full-table dumps: search requires at least one substantive filter; award_type_code alone is not enough.

Awarding Office and Contracting Officer Contacts

Each transaction carries the full agency hierarchy: awarding_agency_name, awarding_sub_agency_name, awarding_office_name, and the matching code fields. These tell you which office issued the contract and which office holds the re-compete. To see how any of those offices buys, its NAICS mix, average offers per award, single-bidder share, and set-aside lean, look up the office in Contracting Office Intelligence (GET /api/v1/offices/{office_code}).

Personal contact information (specific contracting officer name and email) is not part of the federal procurement record. For that data, use the contracting officer directory below, which indexes contacts by office and by past award.

contacts.govconapi.com

Search 37,000+ contracting officer profiles, agency, email, award history, and active solicitations. Free to browse, no API key needed.

Search CO Database →

Pagination

Search and modification trails both cap at 100 results per request on the free trial and 1,000 on paid plans, the same page-size rule as every list endpoint.

# Page 1
GET /api/v1/contracts/search?naics=541512&agency=defense&limit=250&offset=0
→ { "data": [...], "pagination": { "limit": 250, "offset": 0, "total": 54332, "has_next": true } }

# Page 2
GET /api/v1/contracts/search?naics=541512&agency=defense&limit=250&offset=250
→ { "data": [...], "pagination": { "limit": 250, "offset": 250, "total": 54332, "has_next": true } }

# Stop when has_next is false

Rate limits

Two layers, both enforced:

1,000 requests per hour per API key (Developer plan). This is the sustained limit.
60 requests per minute per IP, across all endpoints. This is a burst ceiling.

Hit either and you get a 429 with a Retry-After header. Both X-RateLimit-Limit and X-RateLimit-Remaining are present on every response so you can pace your client.

Common Use Cases

Competitive intelligence by NAICS

Filter by NAICS and date range to see every recipient winning work in your category, what they were obligated, which agencies are awarding it, and at what cadence. Sort by federal_action_obligation descending to find the largest single actions, or by current_total_value_of_award for the largest ceilings.

Recipient due diligence

Pull a recipient's full contract activity by UEI to see total obligations, agency mix, NAICS spread, and set-aside posture before teaming or subcontracting. Use parent_uei for the corporate roll-up across subsidiaries.

Re-compete research

Look up a contract by PIID to see the latest action, the ceiling, the period of performance, and the awarding office. Pull the modification trail to understand what changed over the contract's life and where the option exercises sit.

Subaward and supply-chain analysis

On Pro, the detail endpoint returns a populated subaward_rollup for contracts with FFATA filings. For vendor-wide subaward activity, switch to the UEI-keyed reverse lookup at /companies/{uei}/subawards.

BD pipeline polling

Poll with date_from set to your last sync timestamp to fetch only new actions. Combine with NAICS or agency filters to keep the result set scoped. Recipient UEI and PIID are stable identifiers you can store and re-query against.

Contract Context on the Rest of the API Pro

FPDS prime contract activity stitches into the rest of the GovCon API surface so a single endpoint call can return the full federal picture without round-trips:

/companies/{uei} returns fpds_obligated_total, fpds_distinct_contracts, fpds_transaction_count, fpds_first_action_date, fpds_latest_action_date, fpds_top_naics (up to 5), and fpds_top_agencies (up to 5) alongside the existing SAM Award Notice totals and subaward income aggregates. The combined view answers "what's this UEI's complete federal activity?" in one call.
/entities/{uei} and /entities/by-cage/{cage} return the same fpds_obligated_total and date-bound activity on the SAM entity record. Vendor-onboarding reads federal scale alongside registration data in the call your CRM is already making.
/vendor-risk/{uei} returns a contract_exposure block with obligation flow, transaction count, distinct contracts, action-date bounds, and top awarding agencies. Compliance teams read FPDS exposure alongside the seven existing risk signals and the subaward_exposure block.
/exclusions/{uei_sam} returns a recent_contract_actions block summarizing direct prime contract obligations the excluded UEI has received in the last 12 months: net obligated, transaction count, distinct contracts and agencies, most-recent action (date, amount, agency, PIID), top paying agencies. The compliance question goes from "are they debarred?" to "is anyone still paying them?" in one call.

All enrichment blocks are silently omitted on Free / Developer keys. _sources on every response composes the underlying source identifiers (sam_entities, usaspending_fpds, usaspending_ffata, ...) so callers know exactly which data layers fed the response.

Linking Contracts to Other Surfaces

Beyond the inline enrichment above, contract records cross-link into the rest of the API through stable identifiers.

recipient_uei joins to /api/v1/entities/{uei} (SAM registration), /api/v1/companies/{uei} (cross-source view), /api/v1/vendor-risk/{uei} (seven-signal screening), and /api/v1/exclusions/{uei} (debarment screening).
award_id_piid joins to /api/v1/subawards/search?piid={piid} for the full subaward record set and to /api/v1/opportunities/search?solicitation_number={...} for the originating notice when one was published.
recipient_parent_uei rolls up across subsidiaries for corporate-group queries.
contract_award_unique_key is the global join key when PIID alone is ambiguous (same PIID assigned by two different agencies).

How It Compares

	GovCon API Contracts	FPDS direct	USAspending API	SAM.gov Direct
Response format	JSON	SOAP / XML	JSON	JSON
Search by recipient UEI	Yes (exact, case-insensitive)	Yes (UEI / CAGE / DUNS)	Partial (via recipient profile)	No direct filter
Search by PIID	Yes (exact)	Yes	Yes	Indirect (via opportunity)
NAICS in search response	Yes	Yes	No (null on search; fetch detail)	Yes
Modification trail	Yes (dedicated endpoint, ASC)	Yes	Partial	No
Subaward enrichment on detail	Yes (Pro, ~88% on FY2025+)	No	Separate dataset	No
Coverage	FY2025 + FY2026; expanding	Back to FY 2008	Back to FY 2008	Recent notices only
Setup time	Minutes	Hours (SOAP setup)	Minutes (no key required)	2-3 weeks (entity reg)

Data Source and Coverage

Data is sourced from the federal procurement system of record (FPDS) for prime contract types A, B, C, and D, refreshed daily.

Coverage today: FY2025 + FY2026 (action dates from October 2024 onward). 9 million+ transactions, 8 million+ distinct contracts, 100,000+ recipients.
Refresh cadence: daily. Upstream lag is typically 1 to 2 days from action date to availability.
Plan window: 5 years. The customer-facing earliest_searchable field in every response is the actual floor, so window math is always honest.
Older fiscal years: a coverage floor, not a plan limit. No plan reaches further back today; backfill will extend the window as it lands.
Indefinite delivery vehicles (IDVs): the parent vehicles themselves are not in this scope; the orders and modifications against them are. To find the parent IDV for an order, use parent_award_id_piid.
Grants and assistance awards: not in scope. This endpoint is FAR-based prime contracts only.

Pricing

Contract search is included on every paid plan; the Pro plan adds subaward enrichment on the detail endpoint.

Free trial (14 days): all filters available, 100 results per request.
Developer: all filters, 1,000 results per request, 1,000 requests per hour.
Pro: Developer access plus subaward_rollup on the detail endpoint, vendor-risk and companies enrichment, and the wider field-projection tiers.

Every parameter is available on every paid plan; the differences across tiers are result count per request, enrichment access, and rate limits. See full pricing.

API Documentation — full endpoint reference
Subawards API — FFATA subaward layer, supply-chain mapping
SAM.gov API Guide — how SAM.gov's own API works and where it falls short
USAspending API Guide — working with the public federal spending API directly
Exclusions Guide — debarment screening and compliance