# Municibid Government Surplus Auction Scraper (`crawlerbros/municibid-scraper`) Actor

Scrape live government-surplus auction listings from Municibid.com - browse by category, search by keyword, filter by ZIP/radius or seller agency, sort by price/bids/ending time, and get full listing detail: description, condition, seller, current bid, bid count, auction end time, and images.

- **URL**: https://apify.com/crawlerbros/municibid-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Agents
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Municibid Government Surplus Auction Scraper

Scrape **Municibid.com** — the online marketplace where U.S. government agencies (cities, counties, school districts, police & fire departments) sell surplus vehicles, equipment, and supplies at auction. Browse all active listings, filter by category / ZIP radius / seller agency, search by keyword, sort by price or ending time, or look up specific listings by ID — with full detail per item including description, condition, seller, current bid, bid count, auction end time, and photos. No login, no cookies, no API key required.

### What this actor does

- **Browse & search** every active (or completed) auction listing on Municibid
- **32 official categories** — Automotive, Heavy Equipment, Police & Fire, Tractors, Trailers, and more
- **Location radius search** — center on a ZIP code and a mile radius
- **Seller/agency filter** — pull every listing from one government agency
- **8 sort orders** — ending soonest, newest, price, bid count, title
- **Direct lookup** by listing ID or URL
- **Full item detail per listing** — description, condition, seller, item location, current bid, bid count, auction end time, and photo gallery
- Empty fields are omitted from every record

### Output per listing

- `listingId`, `title`, `url`
- `description`, `category`, `categoryUrl`, `condition` (New / Used / Refurbished / Damaged)
- `sellerName`, `sellerSlug`, `sellerUrl` — the government agency running the auction
- `city`, `state`, `zipCode` — approximate item location (based on the seller's ZIP)
- `currentBid`, `currency`, `bidCount`, `highBidderMasked` (partially-masked username, e.g. `K*******n`), `reserveStatus` (`No Reserve` / `Reserve Price Met` / `Reserve Price Not Met`)
- `status` — `active` or `ended`
- `auctionStartTime`, `auctionEndTime` — ISO 8601 UTC timestamps
- `pageViews` — listing page view count at time of scrape
- `thumbnailUrl`, `imageUrls[]`, `imageCount`
- `recordType: "listing"`, `scrapedAt`

`currentBid`, `bidCount`, and `auctionEndTime` are **live, time-of-scrape snapshots** — Municibid auctions update continuously, so re-running the actor against the same listing will return the current values at that moment, not a fixed price. This is expected behavior, not a data-quality issue.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `browse` | `browse` (search/filter listings) or `byListingId` (direct lookup) |
| `searchQuery` | string | – | Keyword search, e.g. `truck`, `mower` (mode=browse) |
| `category` | select | All categories | One of Municibid's 32 categories (mode=browse) |
| `sortBy` | select | Ending soonest | Ending soonest / Newest / Price low-high / Price high-low / Most bids / Title A-Z / Title Z-A / Preview |
| `status` | select | Active auctions | Active or completed auctions |
| `zipCode` | string | – | Center ZIP for a radius search (pair with `milesRadius`) |
| `milesRadius` | int | `100` | Radius in miles from `zipCode` (5–1000) |
| `seller` | string | – | Exact seller/agency slug (from a listing's `sellerSlug` field) |
| `minCurrentBid` | int | – | Drop listings below this current bid (USD) |
| `maxCurrentBid` | int | – | Drop listings above this current bid (USD) |
| `minBidCount` | int | – | Drop listings with fewer bids than this |
| `maxBidCount` | int | – | Drop listings with more bids than this |
| `condition` | select | Any | Filter to New / Used / Refurbished / Damaged |
| `listingIds` | array | – | Listing IDs or URLs to fetch directly (mode=byListingId) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–1000) |

#### Example: browse all active listings, ending soonest

```json
{
  "mode": "browse",
  "maxItems": 50
}
```

#### Example: search vehicles in the Automotive category

```json
{
  "mode": "browse",
  "category": "C160883",
  "searchQuery": "truck",
  "sortBy": "2",
  "maxItems": 100
}
```

#### Example: listings within 50 miles of a ZIP code

```json
{
  "mode": "browse",
  "zipCode": "60601",
  "milesRadius": 50,
  "maxItems": 100
}
```

#### Example: all listings from one seller agency

```json
{
  "mode": "browse",
  "seller": "CityofFarmingtonILPD",
  "maxItems": 50
}
```

#### Example: direct lookup by listing ID

```json
{
  "mode": "byListingId",
  "listingIds": ["83611256", "84094594"]
}
```

### Use cases

- **Government surplus resellers** — track new vehicle/equipment listings across agencies
- **Auction aggregators** — feed Municibid listings into a broader auction search product
- **Price research** — monitor current bid trends for a category over time
- **Fleet buyers** — find surplus vehicles from police/fire/municipal fleets near a location
- **Deal alerting** — filter by category + max bid to surface underpriced listings

### FAQ

**Is this affiliated with Municibid?**
No. This is an independent, third-party actor that reads Municibid's public, unauthenticated auction pages.

**Do I need an account or cookies to use this?**
No. Municibid's browse and listing pages are fully public.

**Why do `currentBid` and `bidCount` change between runs?**
Because they're live auction data. Each run captures a snapshot at the moment of the request.

**Why does a keyword search sometimes return listings that don't match my query?**
Municibid's own search falls back to showing other active listings when a query has no matches, rather than returning an empty page — this is upstream site behavior, not an actor bug.

**Why do `zipCode` + `milesRadius` need to be set together?**
Municibid's location filter only takes effect when both a center ZIP and a radius are supplied; a ZIP alone (or radius alone) is ignored by the site.

**How do I filter by a specific agency?**
Copy the `sellerSlug` value from any listing you've already scraped (e.g. `CityofFarmingtonILPD`) into the `seller` input field.

**Are `minCurrentBid` / `maxCurrentBid` applied by Municibid or by the actor?**
By the actor, after fetching each listing — Municibid's own price-range filter does not reliably narrow results server-side.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text keyword search (mode=browse), e.g. `truck`, `laptop`, `mower`. Leave blank to browse all active listings. Note: Municibid's own search falls back to showing popular listings when a query matches nothing, rather than returning zero results — this is upstream site behavior.

## `category` (type: `string`):

Restrict to a Municibid category (mode=browse).

## `sortBy` (type: `string`):

Listing sort order (mode=browse).

## `status` (type: `string`):

Active (live, biddable) or completed (ended) auctions (mode=browse).

## `zipCode` (type: `string`):

Center point for a location radius search (mode=browse). Must be paired with `milesRadius` to take effect.

## `milesRadius` (type: `integer`):

Only include listings within this many miles of `zipCode` (mode=browse). Requires `zipCode` to be set.

## `seller` (type: `string`):

Restrict to one seller/agency, using the exact slug from a listing's `sellerSlug` output field (mode=browse), e.g. `CityofFarmingtonILPD`.

## `minCurrentBid` (type: `integer`):

Drop listings with a current bid below this amount (applied after fetch).

## `maxCurrentBid` (type: `integer`):

Drop listings with a current bid above this amount (applied after fetch).

## `minBidCount` (type: `integer`):

Drop listings with fewer bids than this (applied after fetch).

## `maxBidCount` (type: `integer`):

Drop listings with more bids than this (applied after fetch).

## `condition` (type: `string`):

Only include listings with this item condition (applied after fetch).

## `listingIds` (type: `array`):

Municibid numeric listing IDs, e.g. `83611256`. Also accepts full listing URLs.

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

Hard cap on emitted records.

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

Optional. Only used as an automatic fallback if Municibid starts blocking requests (403/429). Leave the default on.

## Actor input object example

```json
{
  "mode": "browse",
  "searchQuery": "",
  "category": "",
  "sortBy": "0",
  "status": "active_only",
  "milesRadius": 100,
  "condition": "",
  "listingIds": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped Municibid auction listings.

# 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 = {
    "mode": "browse",
    "searchQuery": "",
    "category": "",
    "sortBy": "0",
    "status": "active_only",
    "milesRadius": 100,
    "condition": "",
    "listingIds": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/municibid-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 = {
    "mode": "browse",
    "searchQuery": "",
    "category": "",
    "sortBy": "0",
    "status": "active_only",
    "milesRadius": 100,
    "condition": "",
    "listingIds": [],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/municibid-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "browse",
  "searchQuery": "",
  "category": "",
  "sortBy": "0",
  "status": "active_only",
  "milesRadius": 100,
  "condition": "",
  "listingIds": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/municibid-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/municibid-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/tUtffwoXrX4jm5ebj/builds/FhTOnazlqemDvIvba/openapi.json