TED, SAM.gov & Grants Monitor for Public-Sector Bid Alerts

Get recurring TED, SAM.gov, and Simpler.Grants.gov bid alerts with a summary-first output built for public-sector tender monitoring, award watch, rebid signals, and grants deadline tracking. Track government tenders, award-like notices, and grants without maintaining fragile scrapers, then review the dataset before turning on webhook delivery.

Store Quickstart

• Start with store-input.example.json. It is intentionally tuned to jurisdictions=eu so the first Store run uses TED only and does not depend on a SAM.gov API key.
• If the output fits, switch to store-input.templates.json and pick one of:
  • TED Quickstart (EU Tenders) for the easiest first success
  • TED Public-Sector Bid Alerts (EU) when you want recurring TED-first bid alerts with top buyers and next actions
  • TED + Grants Pipeline Watch when you want EU tenders plus US grants without adding SAM.gov first
  • TED + SAM Award Watch when capture teams want awarded / closed notice visibility for incumbent movement
  • TED + SAM Rebid Watch when you want renewal, recompete, and follow-on phrasing surfaced in the summary
  • Buyer / Incumbent Tender Watch when you want watchTerms to highlight agencies, frameworks, or competitor names
  • TED Cross-Border Public-Sector Watch when UK-based teams want a TED-first cross-border pipeline without adding a separate UK connector
  • Grants Deadline & Status Alerts when you want deadline_changed, status_changed, and closing_soon alerts across recurring grants runs
  • Closing-Soon Grants Webhook when a notifier or CRM should receive only action-needed grants alerts
  • SAM.gov Federal Bid Alerts when you want SAM.gov-heavy coverage
  • TED + SAM + Grants Daily Bid Alerts when you are ready to monitor both regions plus grants in one recurring lane
  • Bid Alerts Webhook (TED + SAM) when the dataset should feed a CRM or notifier

The fastest path to value is: first successful TED run, then add grants for a grants + tenders view, then add watchTerms for buyer / incumbent overlays, then add us and tighter NAICS filters once you know the normalized output is useful.

TED Cross-Border Public-Sector Watch relies on TED coverage for TED-published opportunities. This actor does not yet include a separate UK-only source connector. Templates that include us or grants assume the corresponding SAM.gov / Simpler.Grants.gov credentials are available for full coverage.

Who gets value fastest?

Team	Why
Bid teams / capture managers	Turn TED and SAM.gov notices into a daily bid queue with same-day review, award watch, and rebid signals
Agencies / bid consultants	Run multi-client public-sector tender monitoring across TED, SAM.gov, and grants without maintaining scrapers
Public-sector growth teams	See grants deadlines, tender deadlines, and buyer concentration in one recurring summary
Competitor / incumbent watch	Highlight buyer, framework, or competitor names with watchTerms while keeping a broader tender feed

What you get in the first run

• Normalized notice rows from TED, SAM.gov, and Simpler.Grants.gov (when enabled)
• relevanceScore so the dataset is sortable immediately
• riskFlags for missing deadlines, missing buyers, low value, or thin-fit opportunities
• meta.executiveSummary with actionNeeded, topOpportunities, topBuyers, source mix, and recurring cadence guidance
• watchTermHits, signalTags, lanePriority, and recommendedAction on each notice for buyer / incumbent / award watch overlays
• alerts[] + meta.alerts when recurring grants snapshots detect deadline_changed, status_changed, or closing_soon
• A dataset you can review before wiring webhook delivery or schedules

What this Actor does:

• Source connectors: TED + SAM.gov + Simpler.Grants.gov
• SAM fallback: if strict SAM filters return zero, actor retries once with relaxed SAM query
• Grants fallback: if keyword-constrained grants search returns zero, actor retries once without the text query
• Recurring grants deadline / status alerts: deadline_changed + status_changed + closing_soon
• Watch-term overlays for buyer, competitor, incumbent, and framework monitoring
• Executive summary surfaces for recurring bid-alert lanes: actionNeeded, topOpportunities, topBuyers, and source mix
• Notice-level signal shaping for award watch, rebid signals, and same-day review
• Normalized output schema
• Deduplication via hash(source + noticeId + deadlineAt)
• Relevance scoring and risk flags
• Delivery modes: dataset (default), webhook (implemented), email (placeholder)
• Retry with exponential backoff for transient HTTP failures

Use cases:

• TED monitoring for EU public-sector tenders
• SAM.gov federal bid alerts
• Grants deadline watch alongside tenders
• Public-sector buyer monitoring
• Regional tender monitoring across US + EU
• Award watch for incumbent / competitor movement when sources expose awarded or closed notices
• Rebid and follow-on monitoring using renewal / recompete language in notice content
• Buyer or framework monitoring using watchTerms

Suggested recurring monitoring cadence

• Start with a daily TED-only dataset run to validate signal quality and scoring
• Add grants when you want recurring grants + tenders monitoring without requiring SAM.gov
• Add watchTerms for incumbents, award-watch phrases, buyers, or competitor names after the base feed is useful
• Add us plus tighter NAICS filters once the first run proves useful
• Switch to delivery=webhook after the keyword set is stable and the dataset is feeding a CRM or notifier
• Keep grantsAlertStateStoreName stable across recurring runs so grant deltas compare against the same snapshot scope

Recommended recurring run:

• jurisdictions: eu,grants
• keywords: digital services, cybersecurity, climate resilience
• watchTerms: state, framework, award
• grantsFundingInstruments: grant, cooperative_agreement
• grantsAlertClosingSoonDays: 7
• grantsAlertStateStoreName: procurement-intel-grants-state
• minValue: 100000
• daysAhead: 30
• delivery: dataset

Store first-run (success-priority, no SAM key):

• Use store-input.example.json
• Default is jurisdictions=eu so the first run stays TED-only and avoids SAM.gov key dependency

Local Run

1. Set secrets in .env:

cd /volume1/docker/Apify/procurement-intel-actor
cp -n .env.example .env
# then edit .env and paste your real keys

2. Run:

cd /volume1/docker/Apify/procurement-intel-actor
cp -n input.example.json input.json
./scripts/run-with-env.sh
cat output/results.json

The provided input.example.json is configured for a live-style TED + SAM.gov run by default. store-input.example.json is tuned for Apify Store first-run conversion.

Store Listing Ops

Update Store metadata (title/description/categories/example input):

cd /volume1/docker/Apify/procurement-intel-actor
npm run store:optimize

Generate KPI report (7-day runs + search rank probes):

cd /volume1/docker/Apify/procurement-intel-actor
npm run store:kpi

Input

Use input.json or APIFY_INPUT_PATH.

Important fields:

• jurisdictions: ["us","eu","grants"] in any combination
• keywords: string list for TED titles, SAM.gov opportunity titles, and grants query themes
• watchTerms: optional string list for buyer, award-watch, incumbent, framework, or competitor overlays
• cpvCodes, naicsCodes
• grantsApplicantTypes, grantsFundingInstruments, grantsOpportunityStatuses
• grantsAlertClosingSoonDays
• grantsAlertStateStoreName, grantsAlertStateKey
• minValue
• daysAhead
• delivery: dataset|webhook|email
• webhookUrl when delivery=webhook
• includeAwarded: helpful for award watch and rebid-risk style runs
• samFixturePath, tedFixturePath, grantsFixturePath for offline verification
• grantsApiKey is optional and is sent as X-API-Key when provided

Detailed schema: INPUT_SCHEMA.json Output schema: OUTPUT_SCHEMA.json

Output Schema (notice)

Each record contains:

• source (sam|ted|grants)
• noticeId
• title
• buyer
• country
• publishedAt
• deadlineAt
• estimatedValue
• currency
• tags
• relevanceScore (0-100)
• daysUntilDeadline
• urgencyScore, urgencyLevel
• riskFlags
• watchTermHits
• signalTags (urgent_deadline, award_watch, rebid_signal, watch_term_hit)
• lanePriority
• recommendedAction
• url
• dedupeHash

Recurring grants runs additionally emit:

• meta.executiveSummary
• meta.alerts
• alerts[]
• alertTypes, alertEventCount, seenBefore on grants notices

Recurring flagship runs additionally surface:

• actionNeeded, topOpportunities, topBuyers, sourceMix inside meta.executiveSummary
• watchTermHits, signalTags, lanePriority, and recommendedAction on notices

A fuller ready-to-share payload is available in sample-output.example.json for Store and README proof.

Keywords

TED tenders, SAM.gov opportunities, Simpler.Grants.gov monitoring, government tenders, public-sector tender monitoring, federal bid alerts, grants deadline alerts, award watch, rebid watch, framework agreement monitoring, buyer watch, incumbent watch, tender alerts.

Tests

$npm test

Live TED smoke test:

$npm run smoke:live

Reliability Guardrails

Daily canary check (SAM >= 1 required, with consecutive-failure escalation state):

cd /volume1/docker/Apify/procurement-intel-actor
set -a && source .env && set +a
CANARY_MIN_SAM_COUNT=1 \
CANARY_ESCALATE_AFTER=2 \
npm run canary:check

Optional env for canary:

• DISCORD_WEBHOOK_URL: post failure/recovery notifications
• CANARY_RUN_TASK_FIRST=true: trigger one task run before checking
• CANARY_MIN_SAM_COUNT (default 1)
• CANARY_MIN_TOTAL_COUNT (default 1)
• CANARY_MAX_ERRORS (default 0)
• CANARY_MAX_ERRORS_WHEN_SAM_THROTTLED (default 1)
• CANARY_MAX_WARNINGS (default disabled)
• CANARY_MIN_TED_COUNT_WHEN_SAM_THROTTLED (default 1)
• CANARY_ALLOW_SAM_THROTTLE (default true) -> degrade to TED-only while SAM is 429
• CANARY_ESCALATE_AFTER (default 2)
• CANARY_STATE_STORE_NAME (default procurement-intel-canary-state)

When SAM throttle text is missing from actor logs, canary performs a lightweight SAM probe to confirm 429 before switching to degraded mode.

Weekly live contract test (SAM/TED response shape verification):

cd /volume1/docker/Apify/procurement-intel-actor
set -a && source .env && set +a
npm run contract:test:live

Optional env for contract test:

• DISCORD_WEBHOOK_URL: notify on test failure
• CONTRACT_NOTIFY_ON_PASS=true: send pass notification too
• CONTRACT_NOTIFY_ON_DEGRADED=true: notify when degraded pass is used
• CONTRACT_DAYS_BACK (default 14)
• CONTRACT_SAM_LIMIT (default 5)
• CONTRACT_TED_LIMIT (default 5)
• CONTRACT_ALLOW_SAM_THROTTLE (default true) -> treat SAM 429 as degraded pass if TED is healthy

Recovery strict check (use after throttle window):

cd /volume1/docker/Apify/procurement-intel-actor
./scripts/run-recovery-strict-with-env.sh

OpenClaw Cron Example

Once the actor is deployed, you can schedule from OpenClaw by invoking the Apify run API.

/volume1/docker/Apify/procurement-intel-actor/openclaw-cron-example.sh

This script auto-loads .env in the same directory.

Apify Cloud Scheduler

If you run fully on Apify cloud (recommended for home PC outages), use Apify Task + Schedule.

Required env keys in .env:

• APIFY_TOKEN
• APIFY_ACTOR_ID
• APIFY_TASK_ID
• APIFY_SCHEDULE_ID

One-time setup / idempotent update:

cd /volume1/docker/Apify/procurement-intel-actor
set -a && source .env && set +a
npm run apify:cloud:setup

Manual run from task:

$curl -sS -X POST "https://api.apify.com/v2/actor-tasks/${APIFY_TASK_ID}/runs?token=${APIFY_TOKEN}"

Check schedule:

$curl -sS "https://api.apify.com/v2/schedules/${APIFY_SCHEDULE_ID}?token=${APIFY_TOKEN}"

Disable / enable schedule:

curl -sS -X PUT "https://api.apify.com/v2/schedules/${APIFY_SCHEDULE_ID}?token=${APIFY_TOKEN}" \
  -H "content-type: application/json" \
  -d '{"isEnabled":false}'

curl -sS -X PUT "https://api.apify.com/v2/schedules/${APIFY_SCHEDULE_ID}?token=${APIFY_TOKEN}" \
  -H "content-type: application/json" \
  -d '{"isEnabled":true}'

Pricing Playbook (PPE)

Recommended staged pricing for apify-default-dataset-item:

• Stage 1 (now): $0.0001
• Stage 2 (after 7 days without churn): $0.0002
• Stage 3 (after another 7 days): $0.0003

apify-actor-start can stay at $0.00005 initially.

Apify enforces a pricing change cooldown (typically 1 month). To schedule the next change:

cd /volume1/docker/Apify/procurement-intel-actor
set -a && source .env && set +a
NEXT_RESULT_PRICE=0.0002 npm run apify:schedule-price

Seed Early Usage

Create a few successful runs to build initial run history:

cd /volume1/docker/Apify/procurement-intel-actor
set -a && source .env && set +a
SEED_RUNS=2 npm run apify:seed-usage

Notes

• SAM often requires an API key; set samApiKey or SAM_API_KEY.
• If SAM key is missing, the actor skips US source and reports a warning instead of hard-failing.
• Simpler.Grants.gov search uses grantsApiKey / GRANTS_API_KEY when present and supports offline runs via grantsFixturePath.
• delivery=dataset pushes notices to Apify default dataset when APIFY_DEFAULT_DATASET_ID and APIFY_TOKEN are present (Apify cloud run). Without them, it keeps local JSON output only.
• If publish is blocked with public profile, enable your Apify public profile once and rerun npm run apify:cloud:setup.
• TED expert query requires explicit fields and query syntax. This actor sends safe defaults.
• For production monetization, add strong schema validation and source-specific contract tests.
• If this Actor saved time for you, please leave a Store review. Early reviews significantly improve discovery in Apify search.

Related actors

• uspto-patent-scraper — pair patent signals with the same vendors, technologies, or market segments.
• tech-events-intelligence — track conferences and CFPs around the same sector after spotting opportunities.
• apple-podcast-scraper — research companies, executives, or category content discovered during procurement work.