# GovDeals Scraper — New Lot Alerts (`magnova/govdeals-scraper`) Actor

Search GovDeals government surplus auctions by keyword, category, state or ZIP. Get lot title, selling agency, current bid, location, closing time and photo, plus bid counts on category searches. Monitoring mode alerts you to newly listed lots only. $0.005 per lot, no start fee.

- **URL**: https://apify.com/magnova/govdeals-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 lot fetcheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## GovDeals Scraper — New Lot Alerts

Search **GovDeals** government surplus auctions by keyword, category, state or ZIP radius — and get structured lot records: title, selling agency, current bid, location, auction closing time and photo — plus bid counts on category searches. Run it on a schedule with **monitoring mode** and later runs deliver **only newly listed lots**.

GovDeals is where US government agencies — school districts, fire departments, cities, universities, federal surplus programs — auction off surplus vehicles, equipment and property. Those auctions **close and disappear**, so a snapshot you took last week is already history. This Actor reads GovDeals' own public search, the same listings its website shows everyone, logged out with no API key.

### What you get per lot

```json
{
  "recordType": "LOT",
  "lotId": "11694-21088",
  "lotTitle": "*** TAYLOR-DUNN *** (Y)",
  "lotUrl": "https://www.govdeals.com/en/asset/21088/11694?aid=11694-21088",
  "sellerName": "Los Angeles Unified School District, CA",
  "sellerAccountId": 11694,
  "category": "Janitorial Equipment",
  "categoryId": "53",
  "currentBid": 490.0,
  "currency": "USD",
  "bidCount": 21,
  "auctionStartDate": "2026-11-04T10:51:00",
  "auctionEndDateUtc": "2026-11-16T20:00:00Z",
  "auctionEndDateDisplay": "November 16, 2026 03:00 PM EST",
  "city": "Los Angeles",
  "state": "CA",
  "stateName": "California",
  "zip": "90015-3143",
  "country": "United States of America",
  "imageUrl": "https://webassets.lqdt1.com/assets/photos/11694/11694_21088_d92ea63f-b26d-4e7b-920e-bf6f0b7b503a.jpg",
  "isNewAsset": false,
  "source": "govdeals"
}
```

*(A real lot, read live from GovDeals while this Actor was being built and verified.)*

### Inputs

| Input | What it does |
|---|---|
| **Keywords** | Search terms for GovDeals' own search, e.g. `fire truck`, `generator`. Leave empty to browse whole categories. |
| **Categories** | Category pages to browse — the slug from a category page URL (`fire-trucks` from govdeals.com/fire-trucks), the full URL, or a category code. Combines with Keywords. |
| **Search URLs** | GovDeals search URLs you copied from the site; the keyword in each URL is searched. |
| **States** | Only deliver lots in these US states (2-letter codes). |
| **ZIP code + Proximity** | Only deliver lots within a radius of a US ZIP code (GovDeals' own proximity search). |
| **Listed since** | Your own cursor: only lots whose auction opened on or after this ISO date. Independent of the monitor state. |
| **Monitor state store** | A key-value store you pick; the Actor remembers seen lots in it. This is what makes only-new delivery work. |
| **Start monitoring silently** | With a store selected: the first run records the current lots without delivering or charging anything; only lots listed afterwards are delivered. |
| **Maximum lots per run** | Hard cap on delivered (charged) lots per run. |
| **Maximum total charge** | Optional hard stop for the run's charges. |

Searches combine: Keywords + Categories search *within* the categories; each Search URL adds its own search. Up to 10 searches per run, up to 4,000 lots read per search.

### Monitoring mode (only-new delivery)

1. Pick one of your key-value stores in **Monitor state store**.
2. Leave **Start monitoring silently** off to receive the current matching lots once as a baseline (charged), or turn it on to seed silently (nothing delivered, nothing charged).
3. Schedule the run. Every later run delivers only lots listed since — each marked `"recordType": "NEW"` — and charges only for those.

The state remembers every lot a run processed, except lots a capped run could not deliver: those stay unseen and are delivered by the next run. A search that fails leaves its state untouched, so the next run catches up.

### Field reference

| Field | Meaning | Present on |
|---|---|---|
| `lotId` | The lot's ID as GovDeals lists it (`{seller account}-{lot}`) | every record |
| `lotTitle` | Lot title as listed | ≥95% |
| `lotUrl` | The lot's public GovDeals page | every record |
| `sellerName` | The selling agency's public name as listed (some sellers are anonymised by GovDeals itself and ship as listed) | ≥90% |
| `sellerAccountId` | The seller's GovDeals account number | ≥90% |
| `category` / `categoryId` | Category name / GovDeals category code | ≥90% |
| `currentBid` / `currency` | Current bid at read time (for a lot with no bids, the listed starting amount) | ≥90% |
| `bidCount` | Bids at read time — on category/browse searches. GovDeals' keyword search does not publish bid counts, so keyword-search lots omit the field | browse searches |
| `auctionStartDate` | When the lot's auction opened (site-local ISO) — the **Listed since** cursor filters on this | ≥90% |
| `auctionEndDateUtc` | When the auction closes, ISO-8601 UTC | ≥95% |
| `auctionEndDateDisplay` | The closing time exactly as GovDeals displays it, with timezone | ≥90% |
| `city` / `state` / `stateName` / `zip` / `country` | The lot's location as listed | city ≥85%, state ≥90% |
| `imageUrl` | The lot's photo on GovDeals' asset host | lots with a photo |
| `isNewAsset` | True when GovDeals itself flags the lot as newly listed | every record |
| `recordType` | `LOT` (baseline/corpus), `NEW` (monitoring delivery), `SUMMARY` (one per run), `ERROR` (a search that could not be checked) | every record |

Every run ends with one **SUMMARY** record: searches checked, lots read/delivered, duplicates skipped, filter counts, and whether the run stopped early (result cap, charge cap or timeout).

### Pricing

**$0.005 per lot record** — pay per event, **no start fee**. Apify plan tiers discount automatically: SILVER $0.00425, GOLD and above $0.0035.

**Not charged:**

- The run SUMMARY record
- ERROR records
- Lots already delivered by an earlier run (duplicates)
- Lots filtered out by States / Listed since
- Lots silently seeded on a monitorOnlyNew first run
- Lots beyond your Maximum lots / Maximum total charge caps

**What it costs in practice:** 1,000 lots = **$5.00**. A daily monitoring run over a category that lists ~40 new lots a day costs 40 × $0.005 = **$0.20/day ≈ $6/month**. A one-off pull of 250 lots costs **$1.25**.

### Use this Actor from your AI agent

This Actor is agent-ready: its input schema is fully typed and described, and it charges per delivered lot with no start fee.

**MCP (Apify MCP server):**

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "<your token>" }
    }
  }
}
```

Then call the `magnova/govdeals-scraper` tool with, for example:

```json
{ "keywords": "fire truck", "states": ["TX"], "maxResults": 100 }
```

**HTTP API:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/magnova~govdeals-scraper/run-sync-get-dataset-items?token=<your token>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": "generator", "maxResults": 100}'
```

### FAQ

**Is this the official GovDeals API?** GovDeals offers no public API. This Actor reads the same public search service the govdeals.com website itself uses, logged out, exactly as a browser does.

**Why is there no lot description?** GovDeals lot descriptions routinely contain the seller's "asset contact" — a named person with an email address and phone number. This Actor never reads descriptions into records, so that contact layer can never leak into your dataset. Everything in the field table above comes from the listing's structured data.

**Why is `bidCount` missing on keyword searches?** GovDeals' keyword search results don't publish bid counts (its category/browse results do). Rather than fetch each lot's detail page — whose payload carries seller contact details this Actor refuses to touch — keyword-search lots ship without the field, and category/browse lots ship with it.

**What does `currentBid` mean on a lot with no bids?** The listed starting amount — the bid the first bidder would place.

**Why do some sellers show as "Seller 33044 - SFCY"?** GovDeals itself anonymises some sellers on its public listings. The Actor ships the seller name exactly as GovDeals publishes it — it never tries to identify an anonymised seller.

### Legal note

This Actor reads GovDeals' publicly available, logged-out listings — factual business data (lot titles, agency seller names, bids, times, locations) published by public agencies. It uses no login, no account and no CAPTCHA or access-control bypass, and it deliberately never collects personal contact data: lot descriptions and street addresses are not read, and any email or phone number a seller types into a title is stripped before a record ships. You are responsible for using the output in line with GovDeals' terms and applicable law.

# Actor input Schema

## `keywords` (type: `string`):

Search terms for GovDeals' own search, e.g. "fire truck" or "generator". Leave empty to browse whole categories.

## `categories` (type: `array`):

GovDeals category pages to browse — the slug from a category page URL (e.g. "fire-trucks" from govdeals.com/fire-trucks), the full category URL, or a category code. Combined with Keywords when both are given.

## `searchUrls` (type: `array`):

GovDeals search URLs you copied from the site — the keyword in each URL is searched. A URL without a keyword produces an ERROR row explaining what to use instead.

## `states` (type: `array`):

Only deliver lots located in these US states (2-letter codes, e.g. TX, CA). Applied to every lot read; the run SUMMARY reports how many were filtered out.

## `zipcode` (type: `string`):

Only deliver lots near this 5-digit US ZIP code (GovDeals' own proximity search).

## `proximityMiles` (type: `number`):

Radius around the ZIP code, 1–500 miles. Defaults to 25 when a ZIP code is given.

## `listedSince` (type: `string`):

Your own cursor: only deliver lots whose auction opened on or after this ISO date (e.g. 2026-11-14). Independent of the actor's monitor state — use it to re-fetch a window or to bootstrap.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the searches' current lots as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current lots without delivering or charging anything, and only lots listed afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which lots it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the searches' lots as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every lot it processed (including filtered-out ones), so widening your filters later does not re-deliver old lots.

## `maxResults` (type: `integer`):

Hard cap on lots delivered (and charged) in one run, across all searches in the run. Lots a capped run could not deliver stay unseen in monitoring mode and are delivered by the next run if they still match.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged lots reach this amount (checked conservatively at the highest per-lot price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new lots stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## Actor input object example

```json
{
  "keywords": "truck",
  "categories": [
    "fire-trucks"
  ],
  "searchUrls": [
    "https://www.govdeals.com/en/search?kWord=generator"
  ],
  "states": [
    "TX"
  ],
  "zipcode": "90015",
  "proximityMiles": 25,
  "listedSince": "2026-11-14",
  "monitorOnlyNew": false,
  "maxResults": 100,
  "maxTotalChargeUsd": 1
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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": "truck",
    "categories": [],
    "searchUrls": [],
    "states": [],
    "monitorOnlyNew": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/govdeals-scraper").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": "truck",
    "categories": [],
    "searchUrls": [],
    "states": [],
    "monitorOnlyNew": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/govdeals-scraper").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": "truck",
  "categories": [],
  "searchUrls": [],
  "states": [],
  "monitorOnlyNew": false,
  "maxResults": 100
}' |
apify call magnova/govdeals-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/govdeals-scraper"
        }
    }
}
```

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/TuIZUOZl2qD94uuCV/builds/abMXq4MCHuah8w76n/openapi.json
