# GovDeals Auction Results Scraper (`parseforge/govdeals-scraper`) Actor

Scrapes closed GovDeals auction listings by search term, category, or direct URL. Returns final price, bid count, seller, location, and auction dates for each asset.

- **URL**: https://apify.com/parseforge/govdeals-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 75 total users, 6 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $11.99 / 1,000 result items

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### GovDeals Auction Results Scraper

**Scrape GovDeals auction results by keyword, category, or direct URL, up to thousands per run.** Every closed listing comes with final price, bid count, seller, location, and auction dates. No login or API key. Export to CSV, JSON, Excel, or XML.

**Low minimum charge:** $0.02 to start a run, then you only pay for the results you get.

GovDeals lists surplus government assets from police cars to laptops, but the site shows only active auctions and hides historical results behind a clunky search. This Actor reads the public closed-auction pages directly, filtered by keyword, category, make, model, year, state, or auction type, and returns each match in one fixed schema.

| Who uses it | What they scrape GovDeals for |
|---|---|
| Used equipment dealers | Find what similar assets sold for before bidding on the next lot |
| Fleet managers | Track disposal prices for vehicles and heavy equipment across states |
| Market researchers | Build price indexes for surplus government assets by category and region |
| Auction flippers | Spot undervalued assets by comparing final bids against market value |

### What it does

This Actor collects closed GovDeals auction listings by search term, category, or direct URL, and returns each one as a flat row with final price, bid count, seller, location, and auction dates.

- 🔍 **Keyword search:** enter any term like 'ford truck' or 'laptop' and get matching closed listings.
- 🏷️ **Category filter:** use GovDeals category codes like '94A' for Cars or '29' for Computers.
- 🔗 **Direct URL:** paste a specific GovDeals asset URL to scrape that one closed auction.
- 📊 **Structured rows:** every listing returns final price, bid count, seller, location, and auction dates.
- 📁 **Export ready:** download as CSV, JSON, Excel, or XML for analysis or spreadsheets.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with GovDeals data

**📈 Build price benchmarks.**

A used equipment dealer runs the Actor with category '94B' for Trucks and state 'TX' to see what Ford F-150s sold for last quarter, then sets their own bid ceiling.

**🔎 Find undervalued assets.**

An auction flipper searches 'police car' with auction type 'Online Auction' and sorts by final price ascending to spot Crown Victorias that closed below market value.

**🗺️ Track regional demand.**

A market researcher filters by state and category to compare final prices for laptops in California versus New York, revealing where surplus IT equipment moves fastest.

**📋 Audit agency disposals.**

A government auditor scrapes all closed listings from a specific seller agency to verify that assets were sold at fair market value.

### Why choose this scraper

| | What you get |
|---|---|
| **Final price** | The closing bid amount for each sold asset |
| **Bid count** | How many bids the asset received before closing |
| **Seller agency** | The government entity that listed the asset |
| **Location** | City, state, and ZIP of the asset |
| **Auction dates** | Start and end dates for the auction |

### How it compares

This Actor focuses on closed auction results with final prices and bid counts, while the competitors below primarily target active listings or offer fewer filters.

| Feature | ParseForge | GovDeals Scraper - Low-cost💲🔥🚜🏛️ | GovDeals Government Surplus Auction Scraper | GovDeals Government Auction Scraper |
|---|---|---|---|---|
| Closed auction results | Yes | Not listed | Not listed | Not listed |
| Final price | Yes | Not listed | Not listed | Not listed |
| Bid count | Yes | Not listed | Yes | Not listed |
| Filter by make/brand | Yes | Not listed | Not listed | Not listed |
| Filter by model year | Yes | Not listed | Not listed | Not listed |
| Filter by state | Yes | Not listed | Not listed | Not listed |
| Sort by final price | Yes | Not listed | Not listed | Not listed |

### Configure the run

Drive the Actor from a search term, category IDs, or a direct URL, and filters run as each listing is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "searchText": "ford truck",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "searchText": "ford truck",
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.01599 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.60 |
| 1,000 results | $15.99 |
| 10,000 results | $159.90 |

#### Optional extras (from 3 October 2026)

Three opt-in extras open the auction page behind each search result: the full asset record, the seller contact and the bid history. All are off by default, and a block that does not come back is never charged. The per-result price does not change.

| Event | Price | Charged when |
|---|---|---|
| `apify-actor-start` | $0.005 per GB of run memory | the run starts |
| `asset-details` | $0.005 per listing | `includeAssetDetails` is on and the asset record came back (VIN or serial, meter reading, title status, condition, description, photos, attributes, address and coordinates) |
| `seller-contact` | $0.005 per listing | `includeSellerContact` is on and the listing returned a contact email or phone |
| `bid-history` | $0.005 per listing | `includeBidHistory` is on and the auction returned at least one bid |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [GovDeals Auction Results Scraper](https://apify.com/parseforge/govdeals-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to GovDeals through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/govdeals-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your search term or filters. If you provided a startUrl, it overrides all search filters. Also ensure the auction has closed; active auctions are not returned.

**Why are some fields empty in the output?**

Not every GovDeals listing includes every field. For example, some assets may not have a model year or a make/brand. Empty fields are normal for incomplete listings.

**The Actor is running slowly or timing out.**

Reduce maxConcurrency to 1 or 2. This slows down the scraping but reduces the chance of rate-limiting or timeouts.

**I get an error when using a category ID.**

Make sure you are using the correct GovDeals category code. The codes are alphanumeric, like '94A' for Cars. Check the GovDeals category list for the exact code.

### FAQ

| Question | Answer |
|---|---|
| Does this scrape active or closed auctions? | This Actor is built for closed auction results. It reads the public listing pages for auctions that have ended, so you get final prices and bid counts. Active auctions are not included. |
| Can I scrape a specific auction by URL? | Yes. Paste the GovDeals asset URL into the startUrl field and the Actor will scrape that single closed listing, ignoring all search filters. |
| How do I filter by category? | Use the categoryIds field with GovDeals category codes. For example, '94A' for Cars, '94B' for Trucks, '94L' for SUVs, and '29' for Computers. You can find the full list on GovDeals. |
| Can I combine filters? | Yes, all filters are combined with AND logic. For example, you can set categoryIds to '94B', makebrand to 'Ford', and locationState to 'TX' to get only Ford trucks in Texas. |
| What is the maximum number of listings I can scrape? | You set the maxItems field to any number. The Actor will collect up to that many listings per run. There is no hard limit, but be mindful of GovDeals rate limits. |
| Does this need an API key or login? | No. The Actor reads public GovDeals pages directly. You do not need a GovDeals account or API key. |
| What export formats are supported? | You can export the results as CSV, JSON, Excel, or XML from the Apify dataset. |
| Can I sort the results? | Yes, use the sortField and sortOrder inputs. You can sort by final price, location, or auction end date, in ascending or descending order. |
| What if I get rate-limited? | Lower the maxConcurrency setting to reduce parallel requests. The default is 5, but you can set it as low as 1 to be gentle on the site. |
| Does this work for all US states? | Yes, you can filter by any US state abbreviation in the locationState field. Leave it blank to include all states. |

### Related actors

- [govdeals-scraper](https://apify.com/parseforge/govdeals-scraper?fpr=vmoqkp): Another GovDeals scraper focused on active auction listings with geolocation data.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by GovDeals, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `searchText` (type: `string`):

Keyword search query (e.g. 'ford truck', 'laptop', 'police car'). If provided, startUrl is ignored.

## `startUrl` (type: `string`):

GovDeals.com asset URL to scrape a specific closed auction. If provided, search filters are ignored.

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

How many listings to collect per run.

## `categoryIds` (type: `string`):

Category code to filter results (e.g. '94A' for Cars, '94B' for Trucks, '94L' for SUVs, '29' for Computers). See GovDeals category list for all codes.

## `makebrand` (type: `string`):

Filter by manufacturer or brand (e.g. 'Ford', 'Dell', 'Caterpillar').

## `model` (type: `string`):

Filter by model name (e.g. 'F-150', 'Latitude', 'D6').

## `modelYear` (type: `string`):

Filter by model year (e.g. '2020', '2019').

## `locationState` (type: `string`):

Filter by US state abbreviation (e.g. 'CA', 'TX', 'NY').

## `auctionTypeId` (type: `integer`):

Filter by auction type: 3=Online Auction, 4=Buy Now, 5=Make Offer, 1=Sealed Bid. Leave blank for all types.

## `sortField` (type: `string`):

Sort results by this field.

## `sortOrder` (type: `string`):

Sort direction: 'asc' (ascending) or 'desc' (descending, newest/highest first).

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests. Lower this if you get rate-limited.

## `includeAssetDetails` (type: `boolean`):

Adds an assetDetails block to each listing: VIN or serial number, meter reading, title status, condition, full description, every photo, the attribute table, pickup address with coordinates, and the inspection, payment and removal instructions. It is one extra request per listing. Charged only for a row that receives it.

## `includeSellerContact` (type: `boolean`):

Adds a sellerContact block to each listing: the agency contact name, email, phone, organization, website and seller page. It is one extra request per listing, shared with asset details when both are on. Charged only for a row that receives an email or a phone.

## `includeBidHistory` (type: `boolean`):

Adds the full bid ladder to each listing as bidHistory (amount, masked bidder, time, winning flag) plus bidCount. It is one extra request per listing. Charged only for a row that receives at least one bid.

## Actor input object example

```json
{
  "searchText": "ford truck",
  "maxItems": 10,
  "sortField": "auctionEnd",
  "sortOrder": "desc",
  "maxConcurrency": 5,
  "includeAssetDetails": false,
  "includeSellerContact": false,
  "includeBidHistory": false
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "searchText": "ford truck",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "searchText": "ford truck",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "searchText": "ford truck",
  "maxItems": 10
}' |
apify call parseforge/govdeals-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/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/SZdBCF9FpwOzvByvM/builds/46HFWybMgLLgdSQmI/openapi.json