# Municibid Scraper — Government Surplus Auctions & Alerts (`scrapersdelight/municibid-scraper`) Actor

Scrape Municibid government & municipal surplus auctions — lot, current bid, location & close time — by keyword, category, ZIP, price, or state. No login or API key. Schedule it as a new-lot monitor with Slack, email & webhook alerts. $4 per 1,000 lots.

- **URL**: https://apify.com/scrapersdelight/municibid-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 per record returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 🏛️ Municibid Scraper & Government Surplus Auction Monitor

**Scrape live Municibid.com government & municipal surplus auctions — title, current bid, bid count, seller/agency, city & state, close time, description, and full photo gallery — by keyword, category, ZIP radius, price, or state. Then run it on a schedule as a new-lot monitor that pings Slack, email, or webhook the moment a fresh lot drops, so you bid first.**

Turn Municibid into a clean dataset or a real-time deal alert. No login, no browser automation — the live bid, bid count and close time come straight from the server-rendered listing grid.

***

### What does Municibid Scraper do?

Municibid Scraper extracts **government & municipal surplus auction listings** from [Municibid.com](https://municibid.com) and returns clean, structured rows you can export to **JSON, CSV, Excel, or push to your app via API**. Vehicles, dump trucks, heavy equipment, police & fire surplus, electronics, office furniture, real estate and more — sold off by towns, counties, school districts, utilities, and agencies across the US and Canada.

- 🔎 **Search the way the site does** — by keyword, category, ZIP + radius, or price range (all server-side).
- 🗺️ **Filter by state** — keep only the states you want (filtered server-side, one state at a time).
- 💰 **Live current bid + bid count** — read straight from the listing grid, no detail fetch needed.
- 🏢 **Seller & location** — the selling agency, plus city and state.
- 📦 **Item detail** — full description and the complete full-size photo gallery.
- ⏰ **Time-aware** — each listing's end time and live/ended status.
- 🔔 **New-lot monitor** — schedule it and get **Slack / email / webhook alerts** for newly listed lots in your niche.

***

### What data does it extract?

For every surplus listing:

- 🆔 `listing_id`, 🔗 `lot_url`, 🏷️ `title`
- 💵 `current_price`, `starting_bid`, 🔨 `total_bids`, `has_bid`, `is_no_reserve`, `buyers_fee`
- 📝 `description`, 🗂️ `category`, `category_id`
- 🏢 `seller` (the selling agency / municipality), `seller_username`
- 📍 `city`, `state`, `zip`
- ⏰ `start_time`, `end_time` (UTC), 🚦 `status` (active / ended / sold)
- 👀 `watchers`, `page_views`
- 🖼️ `images[]` (full-size gallery), `thumbnail`
- ✨ `is_new` (monitor mode), 🕒 `scraped_at`

***

### Who is it for?

- 🛒 **Surplus flippers & resellers** sourcing vehicles, equipment, and electronics to resell.
- 🚚 **Fleet & equipment buyers** tracking municipal vehicle/heavy-equipment lots nationwide.
- ♻️ **Dealers & exporters** monitoring specific categories across many states.
- 📊 **Auction aggregators** combining Municibid with GovDeals, GSA, PublicSurplus, and others.
- 🏢 **Procurement & research** teams analyzing what agencies sell and for how much.

***

### Two ways to use it

1. **Bulk scrape** — pull active listings for a keyword, category, ZIP radius, price band, or set of states into one clean dataset.
2. **New-lot monitor** *(the recurring play)* — set `monitorMode: true`, attach an **Apify Schedule** (hourly for hot categories), and the actor emits/alerts **only newly-listed lots**. Pair with a keyword or category to keep runs cheap and fast.

***

### How to use it (step by step)

1. Click **Try for free**.
2. Pick a **Search type** (e.g. *By keyword*) and enter your scope (e.g. `dump truck`).
3. *(Optional)* add filters: category, price range, ZIP + radius, listing status, or a list of **states**.
4. *(Optional)* turn on **Fetch full details** for the full description and complete photo gallery.
5. Click **Start**, then open the **Dataset** tab to view/export.
6. *(Optional)* set **monitorMode** + a **Schedule** + an alert channel to get pinged on new lots.

#### Quick start

```json
{ "searchType": "keyword", "keyword": "dump truck", "maxLots": 50 }
```

#### State-filtered example

```json
{ "searchType": "all", "states": ["TX", "OK"], "maxLots": 100 }
```

#### New-lot monitor example (cheap & fast)

```json
{
  "searchType": "keyword",
  "keyword": "generator",
  "monitorMode": true,
  "alertOnNewLot": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…"
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `searchType` | `all` · `keyword` · `category` · `zipcode` |
| `keyword` / `categoryId` / `zipcode` + `radiusMiles` | server-side scope for the chosen search type |
| `states` | optional two-letter state codes, filtered server-side (one state per request) |
| `priceMin` / `priceMax` | only return listings in this current-bid band |
| `statusFilter` | `current` (live) · `sold` · `all` |
| `sortBy` | `newest` · `price` · site default |
| `fetchDetails` | add the full description + complete full-size photo gallery |
| `maxLots` | hard cap per run (0 = unlimited) |
| `monitorMode`, `alertOnNewLot`, `alertOnBidChange`, `watchlistAuctionIds` | recurring watcher + alerts |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |
| `proxyConfiguration`, `requestConcurrency` | proxy + parallelism (datacenter is enough) |

***

### Output

Each listing is one dataset record (fields listed above). Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**. Prices are numbers in USD; `total_bids` is an integer; `images[]` are full-size photo URLs.

***

### How much does it cost?

Pay-per-event — you pay for what you pull, no subscription. Suggested rates:

| Event | What it covers | Suggested price |
|-------|----------------|-----------------|
| `lot-scraped` | each listing returned | ~$0.004 / lot |
| `lot-detail-enriched` | each detail-page fetch (description + gallery) | ~$0.003 / lot |
| `monitor-run-completed` | each scheduled watch run | ~$0.05 / run |
| `new-lot-detected` | each newly listed lot | ~$0.02 / lot |
| `alert-delivered` | each Slack/email/webhook push | ~$0.005 / alert |

*(Final per-event prices are set on the actor's pricing page.)*

***

### Is it legal to scrape Municibid?

Municibid auction listings are **public government-surplus data**, browsable without a login, and the records are item/listing data — not personal data. Scraping publicly available listings is generally legal, but you are responsible for your use: **review the current Municibid Terms of Service before commercial use or resale of the data**.

***

### FAQ

**What is Municibid?**
Municibid.com is a leading online marketplace where local governments — towns, counties, school districts, police & fire departments, utilities — auction surplus property (vehicles, equipment, electronics, even real estate) to the public.

**Do I need an account or login?**
No. The actor reads public listing data directly — no account or cookies required.

**Can I monitor new auctions and get alerts?**
Yes. Turn on `monitorMode`, attach an Apify **Schedule**, and add a Slack/webhook/email channel. Each run emits and alerts **only lots new since the last run**.

**Can I filter by state?**
Yes — add two-letter codes to `states`. Municibid filters by state server-side, so a state-scoped run only pages through that state's listings.

**Can I find bargains or closing-soon lots?**
Use `priceMax` for a price ceiling, and sort/scan by `end_time` to surface listings about to close.

**Does it return photos?**
Yes — `thumbnail` per lot from the grid, and the full-size `images[]` gallery when `fetchDetails` is on.

**How do I export the data?**
JSON, CSV, Excel, HTML, or RSS from the Dataset tab, or via the Apify API.

**Can I integrate with Make, Zapier, n8n, or my backend?**
Yes — use the webhook/Slack channels for alerts, or the Apify API to pipe the dataset anywhere.

***

### You might also like

- 🏛️ Other gov & surplus auction sites (GovDeals, GSA Auctions, PublicSurplus, StorageTreasures)
- 🔨 General online auction & marketplace scrapers
- 📍 Local-listing and facility-data scrapers

***

### Feedback

Found a missing field or want a new filter? Open an issue on the actor — fast fixes and feature requests welcome.

# Actor input Schema

## `searchType` (type: `string`):

How to scope the browse. 'all' walks every active listing; 'keyword' and 'category' filter server-side (cheapest). States (below) are also filtered server-side and combine with any of these.

## `keyword` (type: `string`):

Free-text query matched server-side against listings, e.g. 'dump truck', 'generator', 'mower'.

## `categoryId` (type: `string`):

Municibid category id — filters server-side. Find the id in the URL when you click a category on the site (…/browse?category=NN).

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

Optional two-letter state codes, e.g. TX, CA, PA. Filtered server-side (one state per request), so a state-scoped run only pages through that state's listings. Leave empty for nationwide.

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

ZIP center when Search type = By ZIP + radius. Pair with the radius below.

## `radiusMiles` (type: `integer`):

Search radius around the ZIP. Common values: 25, 50, 100, 200.

## `priceMin` (type: `integer`):

Only return listings with a current bid at/above this. Leave empty for no floor.

## `priceMax` (type: `integer`):

Only return listings with a current bid at/below this — bargain filter. Leave empty for no cap.

## `statusFilter` (type: `string`):

Which listings to include. 'current' = live auctions, 'sold' = closed auctions, 'all' = live first, then closed.

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

Result ordering (applied by Municibid and re-applied to the output). 'newest' = newly listed first; 'price' = lowest current bid first.

## `fetchDetails` (type: `boolean`):

Open each listing's detail page for the full description and the complete full-size photo gallery. One extra request per lot. (Live bid, seller and state already come from the listing grid without it.)

## `maxLots` (type: `integer`):

Hard cap on listings scraped this run (cost/safety guard). Defaults to 50 for a fast first run — set to 0 for unlimited. With a state filter and no keyword, the crawl walks the national feed until it finds this many matches.

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run's seen lots (per scope) and output/alert ONLY newly-listed lots. Pair with an Apify Schedule.

## `alertOnNewLot` (type: `boolean`):

In monitor mode, deliver an alert for each newly-listed lot via the channels below.

## `alertOnBidChange` (type: `boolean`):

Also alert when the current bid changes on a watched listing (see watchlist IDs).

## `watchlistAuctionIds` (type: `array`):

Specific listing ids to track for bid changes when 'Alert on bid/price changes' is on.

## `webhookUrl` (type: `string`):

POST endpoint for new-lot alert payloads (Make / Zapier / n8n / custom). One JSON body per alert.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for formatted new-lot cards.

## `emailRecipients` (type: `array`):

Email addresses for the new-lot digest (sent via apify/send-mail).

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

Proxy settings. Off by default — Municibid answers direct requests, which is faster; if a direct request is ever refused, the run switches to the Apify proxy by itself. Datacenter proxy is enough if you turn it on.

## `requestConcurrency` (type: `integer`):

Max parallel requests for detail fetches. Keep modest to respect the site's rate limits.

## `diagnose` (type: `boolean`):

Dev only. Dumps the raw browse + detail HTML to the key-value store (DEBUG_SEARCH_HTML / DEBUG_DETAIL_HTML) and logs the parsed first row + pagination check, then exits. Leave off for normal runs.

## Actor input object example

```json
{
  "searchType": "all",
  "radiusMiles": 100,
  "statusFilter": "current",
  "sortBy": "default",
  "fetchDetails": true,
  "maxLots": 50,
  "monitorMode": false,
  "alertOnNewLot": true,
  "alertOnBidChange": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "requestConcurrency": 5,
  "diagnose": false
}
```

# Actor output Schema

## `lots` (type: `string`):

The dataset of scraped listings (one item per lot).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/municibid-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 '{}' |
apify call scrapersdelight/municibid-scraper --silent --output-dataset

```

## MCP server setup

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