# SAM.gov & SBIR Federal RFP + Attachment Deep-Parser (`aimindteams/govcon-rfp-deep-parser`) Actor

Finds federal RFPs on SAM.gov and SBIR/STTR solicitations, downloads the attached SOW/PWS/RFP PDFs and DOCX files, and extracts clearance level, LPTA vs. best value, incumbent contract numbers, page limits, compliance frameworks and every .gov/.mil contact. Optional BYOK LLM Go/No-Go summary.

- **URL**: https://apify.com/aimindteams/govcon-rfp-deep-parser.md
- **Developed by:** [AIMindTeams](https://apify.com/aimindteams) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 solicitation with parsed attachments

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

## SAM.gov & SBIR Federal RFP + Attachment Deep-Parser

**Stop opening 40-page PDFs to find out you can't bid.** This Actor finds new federal opportunities on SAM.gov and SBIR/STTR sources, downloads the attached RFP, SOW and PWS files, reads them for you, and returns the facts that decide a bid:

- **Clearance level** (Public Trust up to TS/SCI with Poly) and **DD254**
- **Evaluation method** (LPTA, Best Value Tradeoff or HTRO)
- **Incumbent contract numbers** (PIIDs) and incumbent contractor names
- **Page limits and formatting rules** for each volume
- **Compliance frameworks** (CMMC, NIST 800-171, FedRAMP, ITAR, IL5 and more)
- **Every .gov and .mil email** and phone number buried in the attachments

You don't need a SAM.gov API key or any setup. Press **Start** and the default search returns AI, sensor fusion and autonomy opportunities from the last 7 days.

***

### Why this Actor exists

Most SAM.gov scrapers only return what the search page shows: title, solicitation number and posted date. The information that decides whether you can bid is in the attachments: the Statement of Work, the Section L instructions, the Section M evaluation criteria and the DD254. Capture teams lose hours every week opening those files one at a time.

This Actor opens them for you:

| | Typical SAM.gov scraper | **GovCon RFP Deep-Parser** |
|---|---|---|
| Title, solicitation #, dates, agency | Yes | Yes |
| NAICS, PSC, set-aside, place of performance, POCs | Sometimes | Yes |
| Downloads PDF / DOCX / ZIP attachments | No | **Yes, streamed in memory** |
| Clearance, DD254, polygraph | No | **Yes, with evidence quotes** |
| LPTA vs. best value vs. HTRO | No | **Yes, with evidence quotes** |
| Incumbent PIIDs and contractors | No | **Yes** |
| Page limits, fonts, margins, submission portal | No | **Yes** |
| CMMC / NIST / FedRAMP / ITAR / IL levels | No | **Yes** |
| SBIR / STTR solicitations | No | **Yes, including every open DoD topic** |
| Only new or changed notices on scheduled runs | No | **Yes, built in** |
| AI Go/No-Go summary | No | **Optional, bring your own key** |

***

### How it works

1. **Discover.** Runs a full-text search on SAM.gov's public search API for each keyword, filtered by notice type, NAICS, PSC, set-aside and date. No API key is required. If you add a free SAM.gov API key, the official Opportunities v2 API is used as a second source. SBIR/STTR solicitations come from the SBIR.gov API. When SBIR.gov is offline, the Actor falls back automatically to Grants.gov SBIR/STTR funding opportunities. Every open and pre-release DoD SBIR/STTR topic (Army, Navy, Air Force, Space Force, DARPA, OSD, SOCOM and more) comes straight from DSIP, the DoD SBIR/STTR Innovation Portal, as one item per topic.
2. **Skip what you've already seen (for schedules).** Turn on `deduplicateAcrossRuns` and a persistent Key-Value Store (`GOVCON-SEEN-IDS`) remembers what earlier runs delivered. Each scheduled run then only returns, and only charges for, notices that are new or have changed since (for example, an amendment with a new PWS).
3. **Deep-parse.** Attachments are streamed into memory (never written to disk) with a 15 MB per-file safety cap. The Actor reads the first 60 pages of each PDF, all paragraph and table text of each DOCX, and the PDF/DOCX files inside ZIP packages. The SOW, PWS, RFP and Section L/M files are downloaded first.
4. **Extract.** A deterministic regex and heuristic engine reads the notice description plus every parsed file and returns structured signals with short evidence quotes, so you can check each one in seconds.
5. **(Optional) Summarize.** If you add your own Gemini, OpenAI or Anthropic key, an LLM writes a Go/No-Go call, an executive summary and a mandatory-requirements checklist for each solicitation.

***

### Quick start

**Zero config:** open the Actor and click **Start**.

**Typical capture-team setup** (daily schedule, small-business set-asides in your NAICS codes):

```json
{
    "keywords": ["machine learning", "computer vision", "sensor fusion", "digital engineering"],
    "naicsCodes": ["541511", "541512", "541715", "541330"],
    "noticeTypes": ["o", "k", "p", "r"],
    "setAsideTypes": ["SBA", "SDVOSBC", "8A"],
    "postedWithinDays": 3,
    "maxItems": 100,
    "includeSbir": true,
    "parseAttachments": true,
    "maxAttachmentsPerNotice": 5,
    "deduplicateAcrossRuns": true
}
```

Schedule it daily under **Schedules**, connect the **Slack**, **email** or **Google Sheets** integration, and your team gets only the new RFPs each morning, already qualified.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `keywords` | string\[] | `["artificial intelligence", "sensor fusion", "autonomous"]` | One SAM.gov full-text search per phrase (all words must match). Results are merged and de-duplicated. |
| `naicsCodes` | string\[] | none | Only notices with these NAICS codes. |
| `pscCodes` | string\[] | none | Only notices with these Product Service Codes. |
| `noticeTypes` | string\[] | `["o","p","k","r"]` | `o` Solicitation, `p` Presolicitation, `k` Combined Synopsis/Solicitation, `r` Sources Sought, `s` Special Notice, `i` Intent to Bundle, `u` J\&A, `a` Award. |
| `setAsideTypes` | string\[] | none | `SBA`, `SBP`, `8A`, `8AN`, `HZC`, `HZS`, `SDVOSBC`, `SDVOSBS`, `WOSB`, `WOSBSS`, `EDWOSB`, `EDWOSBSS`, `VSA`, `VSS`. |
| `postedWithinDays` | integer | `7` | Notices posted or modified in the last N days (1 to 365). |
| `maxItems` | integer | `25` | Hard cap on solicitations returned and charged per run (1 to 1000). |
| `includeSbir` | boolean | `true` | Also return open SBIR/STTR solicitations and DoD SBIR/STTR topics (open and pre-release) that match your keywords. |
| `parseAttachments` | boolean | `true` | Download and parse PDF/DOCX/ZIP attachments. Turn off for a fast metadata-only run. |
| `maxAttachmentsPerNotice` | integer | `5` | Files parsed per solicitation, highest priority first. |
| `includeAttachmentText` | boolean | `false` | Adds the cleaned full text of each parsed file (up to 100,000 characters per file). Useful for RAG and AI agents. |
| `deduplicateAcrossRuns` | boolean | `false` | Turn on for scheduled runs: only return and charge for new or updated notices. Each distinct set of filters keeps its own history. |
| `llmProvider` | string | `none` | `none`, `gemini`, `openai` or `anthropic`. |
| `llmApiKey` | secret | none | Your key for the selected provider. Stored encrypted and only sent to that provider. |
| `llmModel` | string | provider default | Optional override. Defaults are `gemini-2.5-flash`, `gpt-4o-mini` and `claude-haiku-5-5`. |
| `samApiKey` | secret | none | Optional free SAM.gov API key. Adds the official Opportunities v2 API as a second discovery source. |
| `proxyConfiguration` | object | no proxy | Enable Apify Proxy only if you run very large searches and start seeing HTTP 429 or 403 responses. |

***

### Output

Each solicitation is one dataset item. Download it as JSON, CSV, Excel or HTML, or read it through the API. The **Overview** view gives a one-row-per-RFP table and the **Compliance & capture intel** view focuses on frameworks, PIIDs and contacts.

Illustrative example (abridged; the values below are invented for this README and are not from a real notice):

```json
{
    "source": "sam.gov",
    "notice_id": "0f3c1a9b2d4e4f6a8b1c2d3e4f5a6b7c",
    "solicitation_number": "W56KGY-26-R-0042",
    "title": "AI-Enabled Multi-Sensor Fusion Analytics Support",
    "url": "https://sam.gov/opp/0f3c1a9b2d4e4f6a8b1c2d3e4f5a6b7c/view",
    "notice_type": "Combined Synopsis/Solicitation",
    "agency": "DEPT OF DEFENSE",
    "sub_agency": "DEPT OF THE ARMY",
    "office": "W6QK ACC-APG",
    "naics_codes": ["541715"],
    "psc_code": "AC12",
    "set_aside": "Total Small Business Set-Aside (FAR 19.5)",
    "posted_date": "2026-10-14T15:02:11Z",
    "response_deadline": "2026-11-13T21:00:00Z",
    "place_of_performance": "Aberdeen Proving Ground, MD, UNITED STATES",
    "points_of_contact": [
        { "name": "Contracting Specialist", "email": "contracting.specialist.civ@army.mil", "phone": "(410) 555-0142", "role": "primary" }
    ],
    "attachments_parsed": 3,
    "attachments": [
        { "filename": "Attachment 1 - PWS.pdf", "file_type": "pdf", "status": "parsed", "page_count": 42, "pages_parsed": 42, "char_count": 118220 },
        { "filename": "Section L and M.docx", "file_type": "docx", "status": "parsed", "page_count": 11, "char_count": 30411 },
        { "filename": "DD254 Draft.pdf", "file_type": "pdf", "status": "parsed", "page_count": 4, "char_count": 9902 },
        { "filename": "Pricing Workbook.xlsx", "file_type": "other", "status": "skipped", "status_reason": "Unsupported file type (PDF, DOCX and ZIP packages are parsed)" }
    ],
    "signals": {
        "clearance_level": "TS/SCI",
        "clearance_evidence": ["[Attachment 1 - PWS.pdf] ...all contractor personnel shall possess a final TS/SCI clearance prior to start of performance..."],
        "polygraph_required": false,
        "has_dd254": true,
        "evaluation_type": "Best Value Tradeoff",
        "evaluation_evidence": ["[Section L and M.docx] ...award will be made using a best value tradeoff source selection process in accordance with FAR 15.101-1..."],
        "referenced_contract_numbers": ["W911QX21C0017"],
        "incumbent_contractors": ["Example Analytics Group, LLC"],
        "security_and_compliance_frameworks": ["CMMC Level 2", "NIST SP 800-171", "DFARS 252.204-7012", "IL5"],
        "submission_constraints": {
            "page_limits": [
                { "pages": 25, "context": "[Section L and M.docx] ...Volume I, Technical, shall not exceed twenty-five (25) pages..." }
            ],
            "formatting_requirements": ["Font size: 12 pt", "Font family: Times New Roman", "Margins: 1 inch", "Paper: 8.5 x 11 in"],
            "delivery_methods": ["PIEE Solicitation Module"]
        },
        "extracted_contacts": ["contracting.specialist.civ@army.mil", "technical.poc.civ@army.mil"],
        "extracted_phone_numbers": ["(410) 555-0142"]
    },
    "llm": {
        "provider": "gemini",
        "model": "gemini-2.5-flash",
        "status": "ok",
        "go_no_go": "REVIEW",
        "go_no_go_rationale": "Strong technical fit, but TS/SCI staffing at start of performance is a hard gate.",
        "executive_summary": "The Army is buying multi-sensor fusion analytics support at Aberdeen Proving Ground...",
        "mandatory_requirements": ["Final TS/SCI for all personnel at start", "CMMC Level 2", "Technical volume max 25 pages", "Submit via PIEE by 13 Nov 2026"],
        "key_risks": ["Incumbent referenced under W911QX21C0017"],
        "recommended_next_steps": ["Confirm cleared staffing plan", "Request incumbent contract details through FOIA"]
    },
    "deep_parsed": true,
    "charged_event": "solicitation-deep-parsed",
    "change_status": "new",
    "scraped_at": "2026-10-16T12:00:05Z"
}
```

#### Signal reference

| Signal | Possible values |
|---|---|
| `clearance_level` | `TS/SCI with Poly`, `TS/SCI`, `Top Secret`, `Secret`, `Confidential`, `Public Trust`, `Unclassified / None Stated` (highest level found wins) |
| `evaluation_type` | `LPTA - Lowest Price Technically Acceptable`, `Best Value Tradeoff`, `HTRO - Highest Technically Rated Offeror`, `Unspecified` |
| `referenced_contract_numbers` | Uniform PIIDs such as `W911NF21C0001`, `FA865019C1234`, `N0001418D1234`, `47QTCA19D00AB`, plus GSA schedules such as `GS-35F-0119Y`. The notice's own solicitation number is excluded. |
| `security_and_compliance_frameworks` | `CMMC` and `FedRAMP` (with the level when the documents name a single one), `NIST SP 800-171`, `NIST SP 800-53`, `ITAR`, `EAR`, `DFARS 252.204-7012`, `DFARS 252.204-7019/7020 (SPRS)`, `DFARS 252.204-7021 (CMMC)`, `IL2`, `IL4`, `IL5`, `IL6`, `FISMA`, `FIPS 140`, `CUI`, `Section 508`, `Zero Trust`, `CJIS`, `HIPAA`, `SOC 2` |
| `submission_constraints.delivery_methods` | `PIEE Solicitation Module`, `SAM.gov`, `Email`, `Vulcan`, `DSIP (DoD SBIR/STTR Innovation Portal)`, `Grants.gov Workspace`, `Research.gov`, `NSPIRES (NASA)`, `eRA Commons / ASSIST (NIH)`, `GSA eBuy`, `FedConnect`, `DoD SAFE`, `Physical delivery (hand carry / courier)` |

Every run also writes a **run summary** to the `OUTPUT` record of the default Key-Value Store. It holds counts of discovered, skipped, scraped and deep-parsed notices, per-source status and warnings. Agents and pipelines can use it to check a run at a glance.

***

### Pricing (Pay-Per-Event)

You only pay for solicitations that are delivered to your dataset:

| Event | When it is charged |
|---|---|
| `solicitation-scraped` | A solicitation is delivered with notice metadata and signals from the description, but no attachment text was available (no attachments, controlled files, or `parseAttachments` is off). |
| `solicitation-deep-parsed` | At least one PDF or DOCX attachment was downloaded and its text was parsed. |

See the **Pricing** tab for the current price of each event.

- With `deduplicateAcrossRuns` on, notices delivered in earlier runs are skipped for free, so a daily schedule only bills for what is new.
- Your run's maximum charge is respected. The Actor checks the remaining budget **before** each item and stops cleanly when the budget runs out.
- LLM costs, if you enable the AI pass, go to your own provider account.

***

### Use it from AI agents (MCP)

Every input field has a default and a plain-language description, so AI agents can call this Actor without any setup.

**Hosted Apify MCP server** (Claude, ChatGPT, Cursor, VS Code and any client that supports remote MCP). Add this server URL:

```
https://mcp.apify.com?tools=AIMindTeams/govcon-rfp-deep-parser
```

**Local stdio server** (for example, Claude Desktop `claude_desktop_config.json`):

```json
{
    "mcpServers": {
        "govcon-rfp": {
            "command": "npx",
            "args": ["-y", "@apify/actors-mcp-server", "--tools", "AIMindTeams/govcon-rfp-deep-parser"],
            "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
        }
    }
}
```

Example prompts:

- "Find Secret-or-lower AI and computer vision RFPs posted this week with small-business set-asides, and list page limits and due dates."
- "Which new sensor fusion solicitations reference an incumbent contract? Give me the PIIDs and contracting officer emails."
- "Pull this week's SBIR/STTR topics on autonomy and summarize the mandatory requirements."

Tip for agents: set `includeAttachmentText` to `true` when the agent needs to answer detailed questions about the documents themselves.

***

### Use it from code

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("AIMindTeams/govcon-rfp-deep-parser").call(
    run_input={
        "keywords": ["counter-UAS", "sensor fusion"],
        "setAsideTypes": ["SBA"],
        "postedWithinDays": 14,
        "maxItems": 50,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    signals = item["signals"]
    print(item["solicitation_number"], signals["clearance_level"], signals["evaluation_type"], item["url"])
```

**cURL** (run and get the items in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/AIMindTeams~govcon-rfp-deep-parser/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["artificial intelligence"], "maxItems": 10}'
```

***

### FAQ

**Do I need a SAM.gov account or API key?**
No. Discovery uses SAM.gov's public search API, and attachments marked public download without a login. A free SAM.gov API key is optional and only adds a second discovery source.

**Which attachments are parsed?**
Public PDF, DOCX and ZIP files (PDF/DOCX inside ZIPs). Each file is capped at 15 MB, and only the first 60 pages of a PDF are read, which covers the SOW and evaluation sections while skipping long FAR clause appendices. Controlled attachments that need a SAM.gov login and explicit access approval are listed with status `skipped`. Spreadsheets, images and legacy `.doc` files are listed as `skipped` too.

**What about scanned PDFs?**
The Actor doesn't run OCR. Image-only PDFs are listed with status `failed` and the reason "no extractable text layer". If a notice has no readable attachments, it is charged as `solicitation-scraped`, not as deep-parsed.

**How accurate are the signals?**
The engine is deterministic: the same text always gives the same result. It is tuned for precision and checks for negations ("no security clearance is required", "tradeoffs are not permitted"). Every clearance and evaluation call includes evidence quotes with the file name, so you can verify it quickly. Treat the output as a fast first read, not a replacement for reading Section L and M before you bid.

**How does deduplication work with several saved tasks?**
History is stored in the `GOVCON-SEEN-IDS` Key-Value Store under a key derived from your filters (keywords, NAICS, PSC, notice types, set-asides, SBIR on/off). Two tasks with different filters never hide results from each other. It is off by default, so one-off searches and AI agents get every match on every run; turn it on in your scheduled task.

**SBIR.gov says its API is under maintenance. Do I still get SBIR results?**
Yes. The Actor tries SBIR.gov first and falls back automatically to Grants.gov SBIR/STTR funding opportunities (NIH, NSF, USDA, DOE and other agencies), including their NOFO PDFs. DoD topics always come from DSIP, so they are covered even when SBIR.gov is down. Each DoD topic is one item with its objective, description, phases, keywords, CMMC level, ITAR flag, Q\&A dates and topic contact. The run summary shows which source was used. Grants.gov sometimes blocks automated downloads of NOFO PDFs. When that happens the opportunity is still delivered with its full synopsis and eligibility text, it is charged as metadata-only, and the attachment entry explains why.

**Is this legal?**
The Actor only reads publicly posted federal procurement data and public attachments. It does not log in or bypass access controls. You are responsible for using the data in line with SAM.gov's terms of use.

***

### Changelog

- **1.1**: DoD SBIR/STTR topics from DSIP (source `dsip`): every open and pre-release topic as its own item, with objective, phases, cost limits, CMMC level, ITAR flag and topic contacts.
- **1.0**: First release. SAM.gov website search and optional v2 API discovery, SBIR.gov with Grants.gov fallback, in-memory PDF/DOCX/ZIP parsing, deterministic GovCon signal engine, cross-run deduplication, Pay-Per-Event billing and optional BYOK LLM Go/No-Go enrichment.

# Actor input Schema

## `keywords` (type: `array`):

Each keyword or phrase runs as its own SAM.gov full-text search (all words must match) and results are merged and de-duplicated. Leave empty to rely only on the NAICS/PSC/set-aside filters.

## `naicsCodes` (type: `array`):

Optional. Only return notices with one of these NAICS codes, for example 541511, 541715 or 541330.

## `pscCodes` (type: `array`):

Optional. Only return notices with one of these Product Service Codes, for example AC12, R425 or 7A21.

## `noticeTypes` (type: `array`):

SAM.gov notice types to include.

## `setAsideTypes` (type: `array`):

Optional. Only return notices with one of these set-asides. Leave empty for all, including full and open competition.

## `postedWithinDays` (type: `integer`):

Only return notices posted or modified in the last N days. Amendments count as updates, so scheduled runs catch new attachments.

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

Hard cap on how many solicitations are returned (and charged) in one run. Your Apify spending limit is also respected.

## `includeSbir` (type: `boolean`):

Also search SBIR/STTR solicitations (SBIR.gov API, with automatic fallback to Grants.gov when SBIR.gov is unavailable) and every open or pre-release DoD SBIR/STTR topic from DSIP.

## `parseAttachments` (type: `boolean`):

Stream the attached PDF, DOCX and ZIP files into memory and run the extraction engine over their text. Turn off for a fast metadata-only run.

## `maxAttachmentsPerNotice` (type: `integer`):

Cap PDF/DOCX downloads per solicitation to keep runs fast. Files that look like the SOW, PWS, RFP, Section L/M or instructions are downloaded first.

## `includeAttachmentText` (type: `boolean`):

Adds the cleaned extracted text of every parsed file (up to 100,000 characters per file) to the output. Useful for RAG pipelines and AI agents. Off by default to keep items small.

## `deduplicateAcrossRuns` (type: `boolean`):

Turn this on for scheduled runs. A persistent Apify Key-Value Store (GOVCON-SEEN-IDS) remembers what earlier runs delivered, so each scheduled run only returns, and only charges for, new or updated RFPs. Each distinct combination of search filters keeps its own history. Leave it off for one-off searches and AI agents, which should get every match on every run.

## `llmProvider` (type: `string`):

Optional AI pass that writes an executive Go/No-Go summary and a mandatory-requirements checklist for each solicitation. Billed to your own LLM account.

## `llmApiKey` (type: `string`):

API key for the selected LLM provider.

## `llmModel` (type: `string`):

Optional. Leave empty to use the provider default (gemini-2.5-flash, gpt-4o-mini or claude-haiku-5-5).

## `samApiKey` (type: `string`):

Optional. Adds the official SAM.gov Opportunities v2 API as a second discovery source (title search), which keeps runs working if the public website API is throttled. Get a free key under Account Details on SAM.gov.

## `proxyConfiguration` (type: `object`):

SAM.gov does not normally need a proxy. Enable Apify Proxy (datacenter) if you run very large or very frequent searches and start seeing HTTP 429 or 403 responses. Residential proxies are not needed and are replaced with datacenter proxies.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence",
    "sensor fusion",
    "autonomous"
  ],
  "noticeTypes": [
    "o",
    "p",
    "k",
    "r"
  ],
  "postedWithinDays": 7,
  "maxItems": 25,
  "includeSbir": true,
  "parseAttachments": true,
  "maxAttachmentsPerNotice": 5,
  "includeAttachmentText": false,
  "deduplicateAcrossRuns": false,
  "llmProvider": "none",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `solicitations` (type: `string`):

Every solicitation with notice metadata, points of contact, parsed attachment details, deterministic GovCon signals (clearance, evaluation method, PIIDs, page limits, compliance frameworks, .gov/.mil contacts) and the optional LLM Go/No-Go enrichment.

## `overview` (type: `string`):

Flattened one-row-per-solicitation view with the key qualification signals. Append \&format=csv or \&format=xlsx for spreadsheets.

## `runSummary` (type: `string`):

Counts of discovered, skipped, scraped and deep-parsed solicitations, per-source status and warnings for this run.

# 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 = {
    "keywords": [
        "artificial intelligence",
        "sensor fusion",
        "autonomous"
    ],
    "noticeTypes": [
        "o",
        "p",
        "k",
        "r"
    ],
    "postedWithinDays": 7,
    "maxItems": 25,
    "maxAttachmentsPerNotice": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("aimindteams/govcon-rfp-deep-parser").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 = {
    "keywords": [
        "artificial intelligence",
        "sensor fusion",
        "autonomous",
    ],
    "noticeTypes": [
        "o",
        "p",
        "k",
        "r",
    ],
    "postedWithinDays": 7,
    "maxItems": 25,
    "maxAttachmentsPerNotice": 5,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("aimindteams/govcon-rfp-deep-parser").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 '{
  "keywords": [
    "artificial intelligence",
    "sensor fusion",
    "autonomous"
  ],
  "noticeTypes": [
    "o",
    "p",
    "k",
    "r"
  ],
  "postedWithinDays": 7,
  "maxItems": 25,
  "maxAttachmentsPerNotice": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call aimindteams/govcon-rfp-deep-parser --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aimindteams/govcon-rfp-deep-parser"
        }
    }
}
```

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/yMLhdI3jTJEzMxLxt/builds/dfsUyt1VZcGGqWoGk/openapi.json