# Pick-n-Pull Scraper — Yard Inventory & New Arrivals (`crawloop/picknpull-scraper`) Actor

Scrape Pick-n-Pull self-service yard inventory for pullers and recyclers. Export year, make, model, VIN, row, arrival date, and yard, and monitor new arrivals.

- **URL**: https://apify.com/crawloop/picknpull-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 vehicles

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

## Pick-n-Pull Scraper — Yard Inventory & New Arrivals

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Pick-n-Pull or Radius Recycling. Data is read from publicly accessible vehicle-search pages only. No login. You are responsible for complying with applicable law (including GDPR where a VIN is personal data) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

Scrape **Pick-n-Pull** self-service yard inventory. Each row is one donor vehicle: year, make, model, VIN, yard row, arrival date, and yard.

Search by year, make, model, ZIP, or VIN. Turn on **monitor mode** and schedule the run to save only new VINs and vehicles that moved to a new row.

**Best for:** pullers, recyclers, and repair shops who check which yard has a donor car before they drive there.

| Copart | IAAI | Row52 | Pick-n-Pull | Car-Part | PartsHotlines |
| :--- | :--- | :--- | :--- | :--- | :--- |
| [Copart Scraper](https://apify.com/crawloop/copart-scraper) | [IAAI Scraper](https://apify.com/crawloop/iaai-scraper) | [Row52 Scraper](https://apify.com/crawloop/row52-scraper) | Pick-n-Pull Scraper ◄── you are here | [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper) | [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) |

> **Auto parts suite** — locate the donor car, price the used part, then compare a new US or EUR catalog price.

| Actor | What it returns |
| :--- | :--- |
| [Row52 Scraper](https://apify.com/crawloop/row52-scraper) | Junkyard donor cars: VIN, yard, row |
| Pick-n-Pull Scraper ◄── you are here | Self-service yard inventory: VIN, row |
| [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) | Used part price, grade, and yard |
| [CarParts.com Scraper](https://apify.com/crawloop/carparts-com-scraper) | US aftermarket price and catalog status |
| [Oscaro Scraper](https://apify.com/crawloop/oscaro-scraper) | French catalog price in EUR |

### When to use this Actor

- **Find a donor car** — Year, make, model, and a ZIP. Results show the yard, the row, and the date the car was added.
- **Watch new arrivals** — Enable `monitorMode` and schedule the same input. The first run stores a baseline. Later runs save new VINs and row moves.
- **Check one VIN** — Pass `vin` to see whether that vehicle is in a yard.
- **One yard** — `yardName` such as `Rancho Cordova` limits the search to that store.

### Key features

- Public inventory search only. No account and no login.
- Live catalog match for make, model, and yard name.
- Year, make, model, VIN, row, arrival date, yard, city, state, and photo when published.
- Monitor mode for new VINs and row moves, keyed by VIN.
- HTTP fetch, 256 MB, no proxy by default.

### Input

| Field | Required | Default | What it does |
| :--- | :--- | :--- | :--- |
| `year` | no | 2016 | Model year or range, for example `2015-2018` |
| `make` | no | Honda | Make, matched to the catalog. Blank searches every make |
| `model` | no | Civic | Model for that make |
| `vin` | no | | Full or partial VIN. Ignores year, make, and model |
| `zipCode` | no | 94560 | US ZIP or Canadian postal code |
| `distance` | no | 100 | Radius in miles. `25000` is unlimited |
| `yardName` | no | | One yard or city, for example `Rancho Cordova` |
| `sortBy` | no | dateAdded | Newest arrivals first |
| `hasImage` | no | false | Keep vehicles that have a photo |
| `maxItems` | no | 30 | Vehicles to save. In monitor mode, caps charged rows, not the scan |
| `maxPages` | no | 3 | Pages to read. About 30 vehicles per page |
| `monitorMode` | no | false | Save only new VINs and row moves after the baseline |
| `monitorStoreName` | no | picknpull-monitor | Named store for VINs seen on earlier runs |
| `resetMonitorState` | no | false | Clear that store and start a new baseline |
| `proxyConfiguration` | no | off | Leave off unless a run is blocked |

#### Example

```json
{
  "year": "2016",
  "make": "Honda",
  "model": "Civic",
  "zipCode": "94560",
  "distance": 100,
  "sortBy": "dateAdded",
  "maxItems": 30,
  "monitorMode": true
}
```

### Output

One dataset item per vehicle.

| Field | Meaning |
| :--- | :--- |
| `vin` | Vehicle identification number. This is the monitor key |
| `year`, `make`, `model` | Donor vehicle |
| `row` | Row in the yard |
| `dateAdded` | Date added, as shown on the search |
| `yardName`, `yardId` | Pick-n-Pull yard |
| `city`, `state`, `postalCode` | Yard location |
| `imageUrl` | Photo when one is published |
| `vehicleUrl` | Public vehicle page |
| `zipCode` | ZIP used for this search |
| `monitorChange` | After the baseline: `new` or `moved` |
| `previousRow` | Prior row when `monitorChange` is `moved` |

```json
{
  "vin": "WA1DKAFP1BA044876",
  "year": 2011,
  "make": "Audi",
  "model": "Q5",
  "row": "29",
  "dateAdded": "Oct 23, 2026",
  "yardName": "PICK-n-PULL Rancho Cordova",
  "yardId": "66",
  "city": "Rancho Cordova",
  "state": "California",
  "postalCode": "95742",
  "vehicleUrl": "https://www.row52.com/Vehicle/Index/WA1DKAFP1BA044876",
  "zipCode": "94560"
}
```

### Use cases

- A puller checks which yard has a 2016 Civic, and which row it is in, before the drive.
- A recycler schedules the same ZIP and model. The next run returns only cars that were not in the yard last time.
- A shop looks up one VIN to see if that car has arrived.
- After a lot on [Copart Scraper](https://apify.com/crawloop/copart-scraper), watch the same year and model here for a self-service donor.
- Once the donor is in the yard, price the part with [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) or [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper).
- Compare a new catalog price with [CarParts.com Scraper](https://apify.com/crawloop/carparts-com-scraper), or a French EUR price with [Oscaro Scraper](https://apify.com/crawloop/oscaro-scraper). Check other Row52 yards with [Row52 Scraper](https://apify.com/crawloop/row52-scraper).

### Integration examples

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/picknpull-scraper').call({
  year: '2016',
  make: 'Honda',
  model: 'Civic',
  zipCode: '94560',
  distance: 100,
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient()
run = client.actor("crawloop/picknpull-scraper").call(run_input={
    "year": "2016",
    "make": "Honda",
    "model": "Civic",
    "zipCode": "94560",
    "distance": 100,
    "maxItems": 20,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["vin"], item.get("row"), item.get("yardName"))
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~picknpull-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"year":"2016","make":"Honda","model":"Civic","zipCode":"94560","distance":100,"maxItems":20}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/picknpull-scraper`.

Example prompts:

- "Run Pick-n-Pull Scraper for a 2016 Honda Civic within 100 miles of ZIP 94560 and return VIN, row, dateAdded, and yardName."
- "Turn on monitor mode for that Civic search and tell me which VINs are new since the last run."
- "After Pick-n-Pull Scraper finds a 2016 Civic, run PartsHotlines Scraper for the engine price, then CarParts.com Scraper or Oscaro Scraper for a new catalog price."

### Suite next step

Price the part once you know the donor is in the yard: [PartsHotlines Scraper](https://apify.com/crawloop/partshotlines-scraper) or [Car-Part Scraper](https://apify.com/crawloop/car-part-scraper). For other Row52 yards, run [Row52 Scraper](https://apify.com/crawloop/row52-scraper). For a new catalog price, run [CarParts.com Scraper](https://apify.com/crawloop/carparts-com-scraper) or [Oscaro Scraper](https://apify.com/crawloop/oscaro-scraper). For the same vehicle at auction, run [Copart Scraper](https://apify.com/crawloop/copart-scraper) or [IAAI Scraper](https://apify.com/crawloop/iaai-scraper).

### FAQ

**Does this log in to a yard account?**
No. It reads the public inventory search.

**Why is the first monitor run full of vehicles?**
That run is the baseline. Later runs in the same `monitorStoreName` save new VINs and cars that moved to a different row.

**Why did a narrow search return nothing?**
That year and model may not be in range of the ZIP. The run finishes with 0 vehicles. Widen `distance` or clear `year`.

**Can I watch one store?**
Set `yardName` to the city or yard, for example `Newark`, and schedule `monitorMode`.

# Actor input Schema

## `year` (type: `string`):

Optional model year or range, as on the inventory search. Examples: 2016 or 2015-2018.

## `make` (type: `string`):

Vehicle make, for example Honda. Leave blank to search every make. Matched against the live catalog.

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

Vehicle model, for example Civic. Requires make. Leave blank to search every model of that make.

## `vin` (type: `string`):

Full or partial VIN. When set, year, make, and model are ignored.

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

US ZIP or Canadian postal code. Used with distance to limit yards.

## `distance` (type: `integer`):

Search radius in miles. The inventory search uses 10, 25, 50, 100, 250, 500, or 25000 for unlimited. Other values in that range are sent as entered.

## `yardName` (type: `string`):

Optional yard or city, for example Rancho Cordova. Must match one Pick-n-Pull yard.

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

Newest arrivals first is the right sort for a monitor.

## `hasImage` (type: `boolean`):

Keep vehicles that have a photo.

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

Maximum vehicles to save. 0 saves every row inside maxPages. In monitor mode this caps rows charged on a run, not the scan window.

## `maxPages` (type: `integer`):

Search pages to read. Each page is about 30 vehicles. 0 uses 3 pages.

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

When scheduled, save and charge only new VINs and row moves since the last run. The first run stores a baseline and still returns rows.

## `monitorStoreName` (type: `string`):

Named key-value store that remembers VINs between runs. Use a distinct name per watch.

## `resetMonitorState` (type: `boolean`):

Clear the stored watch before this run. The run becomes a new baseline.

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

Leave proxy off. The public inventory search answers without a proxy. Turn a proxy on only if a run is blocked.

## Actor input object example

```json
{
  "year": "2016",
  "make": "Honda",
  "model": "Civic",
  "vin": "",
  "zipCode": "94560",
  "distance": 100,
  "yardName": "",
  "sortBy": "dateAdded",
  "hasImage": false,
  "maxItems": 30,
  "maxPages": 3,
  "monitorMode": false,
  "monitorStoreName": "picknpull-monitor",
  "resetMonitorState": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Default dataset items — vehicles with year, make, model, VIN, row, arrival date, and yard.

# 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 = {
    "year": "2016",
    "make": "Honda",
    "model": "Civic",
    "zipCode": "94560"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/picknpull-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 = {
    "year": "2016",
    "make": "Honda",
    "model": "Civic",
    "zipCode": "94560",
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/picknpull-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 '{
  "year": "2016",
  "make": "Honda",
  "model": "Civic",
  "zipCode": "94560"
}' |
apify call crawloop/picknpull-scraper --silent --output-dataset

```

## MCP server setup

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