# GovPlanet Scraper - Government Surplus & Military Auction Data (`parseforge/govplanet-scraper`) Actor

Scrape GovPlanet government surplus and military auctions: item, price, meter, location, auction close time, decoded serial number, full inspection report, NSN and demilitarization codes, buyer fees and pickup terms.

- **URL**: https://apify.com/parseforge/govplanet-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.23 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

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

### GovPlanet Scraper - Government Surplus & Military Auction Data

**Scrape every GovPlanet lot — about 25,000 live at any moment — as one flat row, then add the inspection report, the government manifest or the decoded serial number only if you want them.** Humvees, MRAPs, 5-ton cargo trucks, excavators, generators, forklifts, trailers and consumer surplus. No login, no API key. Export to CSV, JSON, Excel, or XML.

GovPlanet is the Ritchie Bros. marketplace where the US Department of Defense and government agencies run their surplus auctions, and it is where most online army surplus and government vehicle auction inventory ends up. This Actor reads the same public listings a buyer sees, then opens each lot and pulls the parts that decide a bid: what the inspector rated, what the NSN and demilitarization code say, what the buyer's fee and sales tax will be, and where the unit has to be picked up.

| Who uses it | What they scrape GovPlanet for |
|---|---|
| Equipment dealers and resellers | Live inventory with condition ratings before committing to a bid |
| Fleet and municipal buyers | Trucks and machines by state, year, meter reading and pickup terms |
| Military vehicle specialists | Humvees and tactical trucks with NSN, demil code and DTID |
| Price and comps analysts | Asking prices, bid increments and auction close times across the network |
| Export and compliance teams | Demil codes, End-Use Certificate notices and export-control flags |

### What it does

Point it at a keyword, a category, a whole auction, or a single item page. Every lot comes back as one flat row with **30 base columns**, and six optional blocks can add **31 more** on top.

**Always included, 30 columns:** item number, canonical and GovPlanet URLs, title, year, make, model, category, sub-category, marketplace, buying format, price with currency, whether it takes bids, meter reading with unit, state, country, latitude and longitude, auction close text, IronClad Assurance flag, spec line, seller notes, thumbnail and full photo.

**Optional, each with its own checkbox and its own price:**

| Block | Turn on | Adds |
|---|---|---|
| Item profile | `includeItemProfile` | 13 columns: price label, bid increment, availability, manufacturer part number, city, postcode, auction open and close timestamps, sale group ID, condition, watcher count, photo count, notices and restrictions |
| Inspection report | `includeInspectionReport` | 5 columns: every component the inspector rated, with star rating, comment and whether a photo backs it, plus the average rating and the deficiency note |
| Government manifest | `includeManifest` | 3 columns: national stock number (NSN / LSN), DoD demilitarization code, DTID and quantity |
| Serial number | `includeSerialNumber` | 1 column: the serial or VIN, decoded from the obfuscated script GovPlanet hides it in |
| Photo gallery | `includePhotoGallery` | 1 column: every inspection photo with caption, component category, thumbnail and high-resolution URL, often 50 to 150 per lot |
| Fees and pickup terms | `includeTermsAndLogistics` | 8 columns: buyer fee schedule, transaction fee percentage, sales tax jurisdiction, payment window, pickup terms and crated shipping dimensions |
| Auction calendar | `includeAuctionCalendar` | One extra row per upcoming auction: name, date, start time, format, marketplace and lot count |

Every box is off by default. A run that leaves them off never opens an item page, and pays only for the rows and the search pages it read.

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

### What you can do with GovPlanet data

**🔎 Find undervalued lots before the auction closes.**

Filter by category, state and year, sort by ending sooner, and read the inspection ratings and deficiency comments on every match.

**🎖️ Track military surplus by stock number.**

The manifest gives you the national stock number, the DTID and the demilitarization code, so an NSN lookup runs against your own table. Search a fleet of HMMWVs by NSN instead of guessing from titles.

**📊 Build a price and condition dataset.**

Asking price, bid increment, meter reading, model year and a component-level condition report on each row, ready for a comps model.

**🚚 Cost a purchase end to end.**

Transaction fee percent, sales tax jurisdiction, payment deadline, pickup window and crated dimensions land on the same row as the price.

**🔔 Watch the auction calendar.**

Pull upcoming auctions with their lot counts and event IDs, then feed those IDs straight back in to scrape every lot in a specific sale.

### Why choose this scraper

| | What you get |
|---|---|
| **No browser, no residential proxy** | GovPlanet's AWS WAF challenge is answered by routing around it, not by launching Chrome. Runs on plain HTTP through a datacenter proxy, so a run is faster and far cheaper. |
| **Nothing extra unless you ask** | Six optional blocks, all off by default. With none of them ticked the run bills `result-item` and `search-page` and nothing else. |
| **Filter on a column without buying it** | Filters run on the complete row, before the unbought columns are dropped. Ask for lots with demil code Q and a 4-star inspection without paying for either block. |
| **The whole network, filtered** | GovPlanet.com lists GovPlanet, IronPlanet, TruckPlanet, Marketplace-E and SalvageSale. Pick one marketplace or take them all. |
| **32 filters** | 12 run on GovPlanet's own facets so filtered-out lots are never fetched; 20 more apply exact bounds the site only offers as coarse buckets, or read a column the search grid does not carry. |
| **Government fields nobody else returns** | NSN, demil code, DTID, End-Use Certificate notices, and the decoded serial number. |
| **Billed on delivery, not on effort** | A block that comes back empty — a lot with no manifest, a serial the site masks — is not charged. |
| **Four export formats** | CSV, JSON, Excel, and XML, from the dashboard or the API. |

### How it compares

The other GovPlanet scrapers return the search grid: title, price, location, a thumbnail and a link. This one adds the detail page — the inspection report, the government manifest, the serial number and the buyer's real costs — and it does that without the headless browser and residential proxies the others need to get past the same anti-bot.

| Feature | ParseForge | lulzasaur | getdataforme |
|---|---|---|---|
| Columns per lot | 30 base, 61 with every block | 19 (24 with details) | 7 |
| Component-level inspection report | Yes | No | No |
| NSN, demil code and DTID manifest | Yes | No | No |
| Decoded serial number / VIN | Yes | No | No |
| Buyer fees, sales tax, pickup terms | Yes | No | No |
| Upcoming auction calendar | Yes | No | No |
| Extra data is opt-in | Yes, seven checkboxes | No | No |
| Filters beyond a keyword | 32 | 0 | 0 |
| Needs a headless browser | No | Yes | Not stated |
| Default proxy | Datacenter | Residential | Apify default |
| Results per request | 100 | 60 | Not stated |

### What a GovPlanet item looks like

With no optional block ticked, every lot returns as this flat row — a real record from a live run, with the seller note trimmed:

```json
{
  "itemId": "15014261",
  "url": "https://www.govplanet.com/for-sale/1987-AM-General-M1097R1-HMMWV-4-Door-Soft-Top-w-Truck-Body-Michigan/15014261",
  "title": "1987 AM General M1097R1 HMMWV 4 Door Soft Top w/Truck Body",
  "year": 1987,
  "make": "AM General",
  "model": "M1097R1",
  "category": "humvee",
  "subcategory": "GovPlanet",
  "marketplace": "GovPlanet",
  "marketplaceCode": "G",
  "realmId": 22,
  "buyingFormat": "Online Auction",
  "price": 3000,
  "priceCurrency": "USD",
  "priceFormatted": "US $3,000",
  "acceptsBids": true,
  "meterReading": 24133,
  "meterUnit": "miles",
  "locationState": "Michigan",
  "locationCountry": "USA",
  "latitude": 43.0259,
  "longitude": -82.9296,
  "auctionCloseText": "Aug 26",
  "ironCladAssurance": true,
  "features": "6.5 L Diesel Engine, Automatic Transmission, 4x4, 10,000 lb. GVWR, 37x12.50R16.5 Tires",
  "catalogNotes": "***Buyer will need to complete and submit a Hold Harmless Agreement before scheduling pickup. Th...",
  "thumbnailUrl": "https://cdn.ironpla.net/i/21693/607/c800c049-cfbd-3b82-9678-6dee306bf934-small.jpg",
  "photoUrl": "https://cdn.ironpla.net/i/21693/607/c800c049-cfbd-3b82-9678-6dee306bf934-nowater.jpg",
  "govplanetUrl": "https://www.govplanet.com/for-sale/1987-AM-General-M1097R1-HMMWV-4-Door-Soft-Top-w-Truck-Body-Michigan/15014261",
  "scrapedAt": "2026-08-20T17:27:44.462Z"
}
```

Tick a block and its columns appear on the same row. `includeManifest` alone adds three:

```json
{
  "manifest": [
    { "nsn": "2320013469317", "demilCode": "Q", "description": "TRUCK,UTILITY", "dtid": "W81DTD53510006", "quantity": 1 }
  ],
  "nsnCodes": ["2320013469317"],
  "demilCodes": ["Q"]
}
```

With all six blocks on, a row carries 61 columns. Untick a block and its columns are absent from the row entirely — not `null`, absent — so a CSV export has exactly the header you paid for.

With the auction calendar enabled you also get rows shaped like this:

```json
{
  "recordType": "auction",
  "saleGroupId": "116375",
  "auctionName": "Government Surplus Auction",
  "auctionDate": "Tue Aug 25",
  "auctionTime": "10:00 AM PDT",
  "auctionFormat": "Online Only",
  "marketplace": "GovPlanet",
  "itemCount": 2328,
  "url": "https://www.govplanet.com/jsp/auction/auction_info.jsp?groupId=116375",
  "itemsUrl": "https://www.govplanet.com/jsp/s/searchAjax.ips?sm=0&msg=116375&prows=100"
}
```

### Filtering on a column you did not buy

Filters run on the complete row, **before** the unbought columns are dropped. So a filter can read a block the run is not paying for.

```json
{ "searchTerms": ["humvee"], "onlyWithManifest": true, "demilCodeIs": ["Q"], "minInspectionRating": 3 }
```

That run opens each item page to check the manifest and the inspection rating, keeps only the lots that match, and still delivers the 30 base columns at the base price. The manifest and inspection columns are neither written nor billed. Seven filters work this way: `minInspectionRating`, `demilCodeIs`, `onlyWithManifest`, `onlyWithSerialNumber`, `maxTransactionFeePercent`, `closingBefore` and `closingAfter`.

Rejected rows are never written and never charged, whichever filter rejects them.

### Configure the run

Feed it any mix of five sources: `searchTerms`, `startUrls`, `itemIds`, `auctionEventIds`, and the auction calendar. The Input tab lists every parameter.

Cheapest useful run — 500 GovPlanet lots, base columns only:

```json
{ "searchTerms": ["humvee"], "marketplaces": ["G"], "maxItems": 500 }
```

Texas dump trucks from 2010 on, with the fees and pickup terms:

```json
{ "categoryIds": ["2274"], "locations": ["USA-TX"], "minYear": 2010, "includeTermsAndLogistics": true, "maxItems": 500 }
```

Military lots with their stock numbers and condition report:

```json
{ "searchTerms": ["humvee"], "marketplaces": ["G"], "includeManifest": true, "includeInspectionReport": true, "includeSerialNumber": true, "maxItems": 200 }
```

Everything in one specific auction, with the full photo gallery:

```json
{ "auctionEventIds": ["116375"], "includePhotoGallery": true, "includeItemProfile": true, "maxItems": 2000 }
```

Read the calendar first, then scrape the sales it names:

```json
{ "includeAuctionCalendar": true, "maxItems": 100 }
```

Paste a category page or a single lot:

```json
{ "startUrls": ["https://www.govplanet.com/Dump+Trucks", "https://www.govplanet.com/for-sale/Humvees/15733324"] }
```

Array filters are expanded into one search each and the results are de-duplicated, because GovPlanet keeps only the first value of a repeated facet. `{"makes": ["Ford", "Chevrolet"]}` runs two searches and returns the union.

### Pricing

Pay-per-event. Two events are fixed; everything else is a box you tick.

**Always charged**

| Event | Price | When it is charged |
|---|---|---|
| `apify-actor-start` | $0.054 | Once per run |
| `result-item` | $0.007 | Per row written, with its 30 base columns. Reading the item page is included, so a run that opens it only to filter pays nothing extra |
| `search-page` | $0.008 | Per result page read, up to 100 lots each |

**Optional, off by default**

| Event | Price | Turned on by | Charged |
|---|---|---|---|
| `item-profile` | $0.006 | `includeItemProfile` | Per row that returns the block |
| `inspection-report` | $0.006 | `includeInspectionReport` | Per row whose report has at least one component |
| `manifest-record` | $0.009 | `includeManifest` | Per lot that carries a government manifest |
| `serial-decode` | $0.003 | `includeSerialNumber` | Per serial actually decoded |
| `media-gallery` | $0.005 | `includePhotoGallery` | Per row whose gallery is returned |
| `logistics-terms` | $0.004 | `includeTermsAndLogistics` | Per row with fee, tax or pickup terms |
| `auction-event` | $0.01 | `includeAuctionCalendar` | Per upcoming auction row, on top of its `result-item` |

A base row costs **$0.007**. With all six blocks on it costs at most **$0.04**, and less whenever a block comes back empty. Prices drop about 11% at higher monthly volume.

| Run | Approximate cost |
|---|---|
| 100 rows, base only | $0.76 |
| 100 rows, all six blocks | $4.06 |
| 1,000 rows, base only | $7.13 |
| 1,000 rows, all six blocks | $40.13 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs are capped at **25 rows per run**, with all 61 columns and all 32 filters available. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 50,000 rows 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 [GovPlanet Scraper](https://apify.com/parseforge/govplanet-scraper?fpr=vmoqkp).
3. Enter `searchTerms`, pick your `marketplaces` and filters, set `maxItems`, and 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) 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 government surplus auctions 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/govplanet-scraper"
```

Then prompt it in plain language:

- *"Find every Humvee on GovPlanet under $5,000 in Texas and list the ones with an inspection rating of 3 or better."*
- *"Pull the next Government Surplus Auction's lot list and group it by category."*
- *"Give me all GovPlanet generators with their NSN and demil code."*
- *"List Texas dump trucks closing this week — base columns only, keep it cheap."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/govplanet-scraper" to collect GovPlanet government surplus auction lots. Input: { "searchTerms": ["<keyword>"], "marketplaces": ["G"], "maxItems": <n> }. It returns itemId, title, year, make, model, price, meterReading, location and photos on every row. Add "includeManifest": true for NSN and demilitarization codes, "includeInspectionReport": true for the condition report, "includeSerialNumber": true for the VIN — each one is optional and billed separately. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

The keyword may match nothing on GovPlanet, or your filters may be mutually exclusive. `marketplaces: ["G"]` plus a category that only IronPlanet stocks returns zero. Drop one filter at a time and watch the "Search matched N items" line in the log.

**Why fewer items than I asked for?**

`maxItems` is a ceiling, not a target. GovPlanet only has what it has — a narrow keyword may match 40 lots — and your exact filters remove more. The log reports how many were rejected.

**Why is a column missing entirely?**

Because its block is off. Unticked blocks are dropped from the row, not set to `null`, so your export has exactly the columns you paid for. Tick the box named in the Pricing table to get them back.

**Why is a column present but empty?**

That is the lot's real state, measured on a live sample of 75 lots across all five marketplaces:

- `manifest`, `nsnCodes` and `demilCodes` exist only on government lots. On GovPlanet lots the manifest fills on about **80%**; across the whole network it is about **17%**.
- `serialNumber` fills on about **79%** network-wide and **87%** of GovPlanet lots. GovPlanet itself masks some serials as `610XXX` for signed-out visitors, and that masked value is what you get.
- `year` and `meterReading` fill on about **71%** and **53%**: a pallet of hand tools has neither.
- `inspectionItems` fills on about **63%** — lots sold without IronClad Assurance carry only a short condition note.
- `deficiencies` is its own section that only some marketplaces use; it fills on about **21%** network-wide and is normally absent on GovPlanet.

An empty column inside a block you bought is not billed: the event fires only when the block actually returns data.

**Why is `category` empty on a keyword search?**

Only a category search carries a real category trail. On a keyword or marketplace search GovPlanet reuses the same markup for the active filter chips, so the Actor leaves `category` null rather than filing a HMMWV under category "humvee". Tick `includeItemProfile` — or any block — and the category comes from the item page instead.

**Why is the run slow?**

Ticking any block makes the run open one item page per lot. With every box off the run reads one page per 100 lots instead, which measured 8 seconds against 79 for the same 10 lots, and is five times cheaper per row. Untick the blocks you do not need, or narrow the search so fewer lots are opened.

**Do I need residential proxies?**

No. GovPlanet is served over plain HTTP with datacenter proxies, and the Actor needs no headless browser. Leave the proxy on its default.

**A column stopped filling.**

GovPlanet changed its page. Email us with your run ID so we can update the parser.

### FAQ

| Question | Answer |
|---|---|
| Do I need a GovPlanet account or API key? | No. It reads public listing and item pages, so there is no login, OAuth or token to manage. |
| What do I get if I tick nothing? | 30 columns per lot: identity, price, meter, category, marketplace, buying format, coordinates, spec line, seller notes and photos. Enough to build a live inventory table on its own. |
| Can I filter on the manifest without paying for it? | Yes. Filters run before the unbought columns are dropped, so `onlyWithManifest`, `demilCodeIs`, `minInspectionRating`, `onlyWithSerialNumber`, `maxTransactionFeePercent`, `closingBefore` and `closingAfter` all work with their blocks switched off. |
| Is GovPlanet the same as GovDeals? | No. GovPlanet is the Ritchie Bros. / IronPlanet marketplace for DoD and agency surplus. GovDeals is a separate site — we have a [scraper for that too](https://apify.com/parseforge/govdeals-scraper?fpr=vmoqkp). |
| Can I get IronPlanet or TruckPlanet lots too? | Yes. GovPlanet.com serves the whole network; set `marketplaces` to any mix of GovPlanet, IronPlanet, Marketplace-E, SalvageSale and TruckPlanet. |
| Can it scrape sold prices and past results? | No. GovPlanet puts closed-auction results behind a login, so this Actor covers items currently for sale. |
| What is a demil code? | A DoD demilitarization code saying how far an item must be destroyed or de-militarized before resale. `A` means no restriction; `Q` means the item requires a specific certificate. The Actor returns the raw code. |
| Does it return live bid counts? | No. GovPlanet renders current bid counts client-side after page load, so they are not in the public HTML. Asking price, price label and bid increment are. |
| How many rows per run? | Free plan: 25. Paid: up to 50,000, bounded by what the search and your filters return. |
| How much RAM does it need? | 512 MB is enough and 1 GB is the default; the detail pass scales its parallelism to whatever the run is given. |
| Is this an official GovPlanet product? | No. It is unofficial and reads only publicly available GovPlanet data. |

### Related actors

- [GovDeals Auction Results Scraper](https://apify.com/parseforge/govdeals-scraper?fpr=vmoqkp): government surplus auctions from GovDeals.
- [Ritchie Bros Auctioneers Scraper](https://apify.com/parseforge/ritchie-bros-auctioneers-scraper?fpr=vmoqkp): heavy equipment from rbauction.com.
- [Machinery Trader Scraper](https://apify.com/parseforge/machinerytrader-scraper?fpr=vmoqkp): dealer listings for construction and farm machinery.
- [BidNet Direct Government Bids Scraper](https://apify.com/parseforge/governmentbids-scraper?fpr=vmoqkp): public-sector solicitations and bid notices.
- [IronPlanet Scraper](https://apify.com/parseforge/iron-planet-scraper?fpr=vmoqkp): heavy equipment listings from IronPlanet.

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 GovPlanet, IronPlanet, Inc. or Ritchie Bros. Auctioneers. It collects only publicly available listing data. You are responsible for using the data in compliance with the site's terms and applicable laws, including US export-control rules that apply to demilitarization-coded property.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search GovPlanet with, one search per term. Example: humvee, generator, forklift.

## `startUrls` (type: `array`):

Paste any GovPlanet URL: a search, a category page such as https://www.govplanet.com/Dump+Trucks, or a single item page. Item URLs go straight to the detail pass.

## `itemIds` (type: `array`):

GovPlanet item numbers to scrape directly, e.g. 15733324. Skips search entirely.

## `auctionEventIds` (type: `array`):

Sale group IDs of specific auctions. Every lot in the auction is returned. Get the IDs by turning on the auction calendar below.

## `includeAuctionCalendar` (type: `boolean`):

Also write one row per upcoming auction (name, date, start time, format, marketplace, lot count and its event ID).

## `marketplaces` (type: `array`):

GovPlanet.com lists the whole Ritchie Bros. online network. Pick GovPlanet for government and military surplus only.

## `buyingFormats` (type: `array`):

How the item sells.

## `categoryIds` (type: `array`):

GovPlanet category IDs, taken from the `c=` parameter of a category page. Examples: 1000 Automobiles, 2274 Dump Trucks, 3 Excavators, 4770 Forklifts, 13 Generators.

## `typeIds` (type: `array`):

Leaf type IDs, from the `t=` parameter in the Type facet. Narrower than a category, e.g. 3856 = T/A Dump Truck.

## `makes` (type: `array`):

Manufacturer as GovPlanet spells it: Cat, Ford, Oshkosh, AM General, Kenworth, Genie.

## `models` (type: `array`):

Model as GovPlanet spells it, e.g. F-450, T800, M1097R1.

## `locations` (type: `array`):

GovPlanet location codes: USA, USA-TX, USA-CA, CAN, CAN-ON, EUR, EUR-ITA, AUS, MEX, NZL.

## `yearBuckets` (type: `array`):

GovPlanet's own year bands. For an exact range use minYear and maxYear instead.

## `priceBands` (type: `array`):

GovPlanet's price facet, written as currency=floor. Examples: p\_us=10000 for $10,000-$49,999, p\_us=-1 for anything priced in USD, p\_can=50000, p\_eu=100000, p\_gbp=-1.

## `ironCladAssurance` (type: `string`):

IronClad Assurance means the item carries a guaranteed inspection report.

## `truckCategory` (type: `string`):

GovPlanet's duty class facet, available on truck categories only.

## `sort` (type: `string`):

How GovPlanet orders the results before pagination. "Ending sooner" is the one to use when you care about auctions about to close.

## `minYear` (type: `integer`):

Exact bound on the model year parsed from the listing. Items with no year are dropped when this is set.

## `maxYear` (type: `integer`):

Upper bound on the model year parsed from the listing.

## `minPrice` (type: `integer`):

In the item's own currency, which is reported in priceCurrency.

## `maxPrice` (type: `integer`):

Upper bound, in the item's own currency.

## `minMeter` (type: `integer`):

Miles, kilometres or hours, whichever the item reports in meterUnit.

## `maxMeter` (type: `integer`):

Upper bound on miles, kilometres or hours.

## `countries` (type: `array`):

Keep only items whose parsed location country matches, e.g. United States, Canada.

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

Keep only items in these states or provinces, e.g. Texas, California, Ontario.

## `titleIncludes` (type: `array`):

Keep an item only if its title, features or seller notes contain one of these words.

## `titleExcludes` (type: `array`):

Drop an item if its title, features or seller notes contain any of these words.

## `onlyWithPhotos` (type: `boolean`):

Drop lots that have no photo on the listing.

## `onlyWithBids` (type: `boolean`):

Drops Buy Now and Make Offer listings that take no bids.

## `onlyWithInspection` (type: `boolean`):

Keep only lots covered by a guaranteed IronPlanet inspection report.

## `minInspectionRating` (type: `integer`):

Keep only lots whose average component rating is at least this many stars, 1 to 5. Reads the inspection block; you do not have to buy it to filter on it.

## `demilCodeIs` (type: `array`):

Keep only lots carrying one of these DoD demil codes, e.g. A, B, Q. Reads the manifest block.

## `onlyWithManifest` (type: `boolean`):

Drops network lots that carry no NSN or demil code. Reads the manifest block.

## `onlyWithSerialNumber` (type: `boolean`):

Drops lots whose serial GovPlanet does not publish. Reads the serial block.

## `maxTransactionFeePercent` (type: `integer`):

Keep only lots whose buyer transaction fee is at or below this percentage. Reads the fees block.

## `closingBefore` (type: `string`):

ISO date or datetime, e.g. 2026-09-01. Keep only lots whose auction closes before it. Reads the item profile block.

## `closingAfter` (type: `string`):

ISO date or datetime. Keep only lots whose auction closes after it. Reads the item profile block.

## `includeItemProfile` (type: `boolean`):

Adds priceLabel, bidIncrement, availability, manufacturerPartNumber, locationCity, locationPostalCode, auctionOpensAt, auctionEndsAt, saleGroupId, itemCondition, watchers, photoCount and noticesAndRestrictions. Bills item-profile per row that returns one.

## `includeInspectionReport` (type: `boolean`):

Every component the IronPlanet inspector rated, with star rating, comment and whether a photo backs it. Bills inspection-report per row that returns one.

## `includeManifest` (type: `boolean`):

GovPlanet lots only: national stock number (NSN / LSN), DoD demilitarization code, DTID and quantity. Bills manifest-record per row that returns one.

## `includeSerialNumber` (type: `boolean`):

GovPlanet hides the serial behind an obfuscated script; this decodes it back to plain text. Bills serial-decode per serial actually recovered.

## `includePhotoGallery` (type: `boolean`):

Every inspection photo with its caption, component category, thumbnail and high-resolution URL, often 50 to 150 per lot. Bills media-gallery per row that returns one.

## `includeTermsAndLogistics` (type: `boolean`):

Buyer fee schedule, transaction fee percentage, sales tax jurisdiction, payment window, pickup terms and crated shipping dimensions. Bills logistics-terms per row that returns one.

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

How many items to write. GovPlanet lists about 25,000 at a time.

## `maxPagesPerSearch` (type: `integer`):

Result pages to read per search before moving to the next one.

## `resultsPerPage` (type: `integer`):

GovPlanet accepts 20, 60 or 100. Leave at 100 for the fewest requests.

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

Datacenter proxy is enough — GovPlanet needs no browser and no residential IP.

## Actor input object example

```json
{
  "searchTerms": [
    "humvee"
  ],
  "startUrls": [],
  "itemIds": [],
  "auctionEventIds": [],
  "includeAuctionCalendar": false,
  "marketplaces": [],
  "buyingFormats": [],
  "categoryIds": [],
  "typeIds": [],
  "makes": [],
  "models": [],
  "locations": [],
  "yearBuckets": [],
  "priceBands": [],
  "ironCladAssurance": "any",
  "truckCategory": "",
  "sort": "bm asc",
  "countries": [],
  "states": [],
  "titleIncludes": [],
  "titleExcludes": [],
  "onlyWithPhotos": false,
  "onlyWithBids": false,
  "onlyWithInspection": false,
  "demilCodeIs": [],
  "onlyWithManifest": false,
  "onlyWithSerialNumber": false,
  "includeItemProfile": false,
  "includeInspectionReport": false,
  "includeManifest": false,
  "includeSerialNumber": false,
  "includePhotoGallery": false,
  "includeTermsAndLogistics": false,
  "maxItems": 100,
  "maxPagesPerSearch": 50,
  "resultsPerPage": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

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

Every scraped item as a flat row, plus one row per upcoming auction when the calendar is enabled.

# 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 = {
    "searchTerms": [
        "humvee"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/govplanet-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 = { "searchTerms": ["humvee"] }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/govplanet-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 '{
  "searchTerms": [
    "humvee"
  ]
}' |
apify call parseforge/govplanet-scraper --silent --output-dataset

```

## MCP server setup

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