Announcing the Protests Endpoint

The Tango API now exposes bid protest records from the Government Accountability Office (GAO) in a single, queryable API. If you're a vendor tracking competitive outcomes, an analyst assessing pipeline risk, or a team building compliance or research tools, you can list and filter protests by outcome, agency, protester, and dates, and request only the fields you need with response shaping. We plan to add additional protest forums in the near future.

In this post we'll cover why it matters, use cases, how it works, how to use it (endpoints, filters, and examples), and key takeaways. Full field definitions and behavior are in the Protests API reference and Protests Data Dictionary.

Why it matters

A bid protest is one of the highest stakes events in federal procurement and bid-protest decisions are highly information rich.

But protest data has mostly been something you read—PDFs and web pages on GAO's site, useful if you already know what you're looking for. By turning those documents into structured, queryable data, protests stop being a reactive research task and instead become a proactive part of business development and capture.

Treating protests as data, you can screen opportunities against protest history before you invest in a bid. You can spot agencies or contract vehicles with patterns of corrective action or sustained protests and factor that into your pipeline strategy. You can build protest signals directly into your capture workflows instead of relying on someone remembering to check.

Tango's protests endpoint are a step in that direction. It puts bid protest records into the same API you already use for contracts, opportunities, and entities—with the same filtering, full-text search, response shaping, and pagination patterns. One API key, one query language, and protest data sits right alongside everything else.

Use cases

Know what happened before you bid

Imagine you're chasing a re-compete and you want to know: was the incumbent's original award protested? By whom? What was the outcome? With the protests endpoint you can filter by solicitation number and get the full history in one call. That's context that used to require manual research. Now, it's a single API call.

Learn how agencies actually evaluate proposals

Protest decisions are one of the few places where agencies have to explain, on the record, how they made award decisions. Did they prioritize technical approach over price? How did they score past performance? What tradeoffs did they accept between cost and technical merit? When GAO reviews a protest, the agency's evaluation rationale becomes part of the public record. That makes protest data a unique window into how specific agencies think about value, how they weight evaluation factors, and where they draw the line on technical acceptability. If you're shaping a proposal, that's the kind of signal that helps you write to how an agency actually evaluates, not just what the solicitation says.

Build protest intelligence into your tools

If you're building a GovCon platform, a proposal management tool, using agentic workflows, or an internal dashboard, the protests endpoint gives you structured, queryable data you can integrate directly. You know what you need, now you can build it!

Research protest patterns at scale

Policy researchers, journalists, and oversight teams can now query protest outcomes across agencies, time periods, and case types without screen-scraping. How often does Agency X face sustained protests? Which companies protest most frequently? Are protest volumes trending up in a particular sector? These questions become API calls instead of manually entered Excel spreadsheets.

You can also link protests to solicitations today via the solicitation_number filter or field; as Tango adds more links between protests and contracts/opportunities, the same API will stay the backbone.

How it works

The protests API is case-level: each result is one case (a GAO bid protest), identified by a deterministic case_id (a UUID derived from source_system and the base case number). A case can have multiple dockets (sub-records); the list endpoint returns one result per case, with case-level fields taken from the most recent docket. If you need docket-level detail, you request it explicitly with the dockets expansion in your shape parameter (e.g. shape=...,dockets(case_number,docket_number,filed_date,outcome)).

List behavior: Filters and pagination are applied to dockets first; results are then grouped by case. So the count you get is the total number of matching cases across all pages, not raw docket count. Ordering is fixed: decision_date when present, otherwise filed_date, newest first, with a UUID tie-breaker. The API does not support a custom ordering parameter (if you send one, you get HTTP 400).

Authentication: Both list and detail require authentication (API key or OAuth2). Unauthenticated requests receive HTTP 401.

Shaping and pagination work like other Tango endpoints: pass shape to choose fields (and optionally expand dockets), and use page and limit (max 100) for pagination. For more on why shaping matters, see The Value of Response Shaping.

How to use it

Endpoints:

• List: GET /api/protests/ — list and filter protests; supports shape, page, limit, and all filters below.
• Detail: GET /api/protests/{case_id}/ — fetch a single case by its UUID (the path segment must be a valid RFC 4122 UUID).

Main filters: outcome (e.g. Denied, Dismissed, Withdrawn, Sustained), case_type, agency, case_number, solicitation_number, protester, filed_date_after / filed_date_before, decision_date_after / decision_date_before, and search (full-text over protest searchable fields). Many filters support OR/AND syntax; see the API reference. A source_system filter is also available and will become more useful as we add protest forums beyond GAO.

Example requests:

Timeline-focused list with minimal shape:

curl -G 'https://tango.makegov.com/api/protests/' \
  -H "X-API-KEY: ${TANGO_API_KEY}" \
  --data-urlencode "shape=case_id,title,outcome,filed_date,decision_date" \
  --data-urlencode "limit=10"

Case-level fields plus nested dockets:

curl -G 'https://tango.makegov.com/api/protests/' \
  -H "X-API-KEY: ${TANGO_API_KEY}" \
  --data-urlencode "shape=case_id,case_number,title,dockets(case_number,docket_number,filed_date,outcome)" \
  --data-urlencode "limit=10"

Detail by case UUID with a shaped response:

curl -G 'https://tango.makegov.com/api/protests/af3327fd-df8c-55e3-a736-ffa4b4c6f9c0/' \
  -H "X-API-KEY: ${TANGO_API_KEY}" \
  --data-urlencode "shape=case_id,source_system,title,agency,protester,filed_date,decision_date"

For the full list of shape fields (case-level and inside dockets(...)), validation rules, and pagination behavior, see the Protests API reference and Protests Data Dictionary.

Key takeaways

1. Bid protest data in one API — List and detail at /api/protests/ and /api/protests/{case_id}/ with auth (API key or OAuth2).
2. Case-level model — One result per case; optional dockets expansion for sub-records.
3. Rich filtering — Filter by outcome, case type, agency, case number, solicitation number, protester, and filed/decision date ranges; full-text search over protest fields.
4. Response shaping — Use shape to request only the fields you need (including dockets(...) when you want docket-level data); invalid shape returns HTTP 400.
5. Fixed ordering — Results are ordered by decision/filed date (newest first); no custom ordering param.
6. Pagination — Standard page and limit (max 100); count is total matching cases.

If you're building in government contracting and care about bid protests—whether for competitive intelligence, pipeline risk, compliance, or research—the new protests endpoint gives you queryable, shaped protest data in the same place as your contracts and opportunities. Try it on the Tango API and use the docs for the full reference.