# Pick-n-Pull Inventory Scraper — Row52 Junkyard Vehicles (`muhammadafzal/row52-scraper`) Actor

Export Pick-n-Pull junkyard inventory from Row52: VIN, make, model, yard row, date added, specs, photos and yard locations. USD 3 per 1,000 vehicles.

- **URL**: https://apify.com/muhammadafzal/row52-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (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 vehicle / yard 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?

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 Inventory Scraper — Row52 Junkyard Vehicles

Pick-n-Pull Inventory Scraper searches the public Row52 inventory of Pick-n-Pull self-service junkyards and returns one record per vehicle with VIN, year, make, model, trim, engine, transmission, color, yard row, date added, photos and the yard's address and hours. It is built for used-parts buyers, auto recyclers, mechanics and restorers who want to know which donor cars are on the lot right now, and it costs USD 3.00 per 1,000 vehicles on the FREE tier (USD 2.40 on GOLD).

### What does the Pick-n-Pull inventory scraper return?

Each dataset row is one vehicle (`recordType: "vehicle"`) or, in yard mode, one junkyard (`recordType: "yard"`). Vehicle rows contain:

| Field | What it contains |
|---|---|
| `vin` | 17-character Vehicle Identification Number |
| `year`, `make`, `model` | Model year and names, plus Row52 `makeId` and `modelId` |
| `trim`, `engine`, `transmission`, `color` | Specifications from the vehicle detail page, for example `3.7L V6 SOHC 24V` |
| `row` | The yard row where the car is parked, for example `71` |
| `dateAdded` | Date the car entered the yard (ISO 8601) |
| `barCodeNumber` | Yard stock or barcode number |
| `locationId`, `yardName` | Yard ID and name, for example `PICK-n-PULL Rancho Cordova` |
| `yardAddress`, `yardCity`, `yardState`, `yardZip`, `yardPhone`, `yardHours` | Yard contact details |
| `yardMapUrl`, `partsPricingUrl` | Links to the yard map and the yard's parts price list |
| `imageUrl`, `images` | Main photo and all photo URLs |
| `partsPullersCount` | Parts-puller count Row52 shows for the vehicle |
| `url` | Row52 vehicle page, for example `https://row52.com/Vehicle/Index/2HNYD2H62CH530637` |
| `scrapedAt` | Collection time (ISO 8601) |

Yard rows contain `name`, `code`, `address`, `city`, `state`, `zipCode`, `phone`, `hours`, `latitude`, `longitude`, `mapUrl`, `partsPricingUrl`, `webUrl`, `isParticipating`, `isActive` and `url`. Fields the source does not provide are `null`.

The run summary is saved as `OUTPUT` in the key-value store: `outcome` (`DATA`, `EMPTY` or `FAILED`), records delivered, total matches in the inventory, and warnings.

### How do I search Pick-n-Pull inventory by make, model, year or ZIP code?

Enter the make and model as plain names. The Actor resolves them to Row52 IDs, then pages through the results until `maxResults` is reached.

```json
{ "searchMode": "vehicles", "make": "Toyota", "model": "Camry", "year": "2010-2015", "maxResults": 25 }
```

- `year` takes one year (`2012`) or a range (`2010-2015`).
- `zipCode` plus `distance` (miles, default 50) limits results to yards near a US ZIP code.
- `locationName` (for example `Rancho Cordova`) or `locationId` limits results to one yard.
- `hasImage: true` keeps only cars with photos; `sort` (`dateadded`, `year`, `make`, `model`, `yard`) and `sortDirection` set the order. The default is newest arrivals first.

To search every make near a ZIP code, leave `make` and `model` empty. The input form pre-fills `Acura` and `MDX` as an example, so clear those two fields first; an API call that omits them searches all makes.

```json
{ "searchMode": "vehicles", "zipCode": "95843", "distance": 50, "maxResults": 50 }
```

If the model name does not match a Row52 model for that make, the model filter is dropped and all models of the make are searched. A test with make `Toyota` and model `MDX` returned Toyota vehicles from 4,245 matches.

### Can I look up a junkyard vehicle by VIN?

Yes. Set `searchMode` to `vin` and enter the full VIN to get that vehicle's detail record. If the VIN is not found directly, the Actor searches Row52 by the VIN characters instead. A partial VIN in `vehicles` mode also works as a pattern search, combined with the make and model filters: `2HNYD2` with the Acura MDX filter matched 82 vehicles in a 2026-09-30 test.

```json
{ "searchMode": "vin", "vin": "2HNYD2H62CH530637", "maxResults": 1 }
```

You can also pass Row52 links in `startUrls`: search URLs such as `https://row52.com/Search?MakeId=67&ModelId=960` (all result pages are followed) or vehicle URLs such as `https://row52.com/Vehicle/Index/2HNYD2H62CH530637`.

### How do I get a list of Pick-n-Pull yard locations?

Set `searchMode` to `yards`. The Actor returns the yard directory from Row52 with address, phone, hours, coordinates and links. On 2026-10-26 the directory held 70 yards in 18 US states, British Columbia and Alberta, almost all of them Pick-n-Pull locations. 51 were marked `isParticipating: true`; yards marked `false` are listed but their inventory is not searchable on Row52.

```json
{ "searchMode": "yards", "maxResults": 100 }
```

### When should I use it, and when not?

**Use it when** you want the current self-service yard inventory for a vehicle platform, for example every 2010–2015 Camry within 50 miles, new arrivals of a rare model, or the row number of a donor car before you drive to the yard. It also suits parts resellers who track intake and turnover across Pick-n-Pull locations.

**Use another Actor when:**

- You want insurance-auction vehicles and bids: [Copart Public Search Scraper](https://apify.com/muhammadafzal/copart-public-search-scraper).
- You want used cars for sale from dealers: [Cars For Sale Scraper](https://apify.com/muhammadafzal/cars-for-sale-scraper) or [CarMax Scraper](https://apify.com/muhammadafzal/carmax-scraper).
- You need part prices per part: the Actor links each yard's price list in `partsPricingUrl` but does not extract the prices.
- You need yards that are not on Row52: only the yards in the Row52 directory are covered.

### How do I run it from code?

JavaScript with `apify-client`:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/row52-scraper').call({
    searchMode: 'vehicles',
    make: 'Honda',
    model: 'Civic',
    zipCode: '95843',
    distance: 100,
    maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const car of items) console.log(car.year, car.model, car.yardName, 'row', car.row);
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("muhammadafzal/row52-scraper").call(run_input={
    "searchMode": "vehicles",
    "make": "Ford",
    "model": "F-150",
    "maxResults": 25,
})
for car in client.dataset(run.default_dataset_id).iterate_items():
    print(car["vin"], car["year"], car["yardName"], car["row"], car["dateAdded"])
```

### Use it from an AI assistant

Pick-n-Pull Inventory Scraper works from Claude, ChatGPT, Cursor or any MCP client through Apify's MCP server. Add the single-tool URL `https://mcp.apify.com/?tools=muhammadafzal/row52-scraper` to your client and ask, for example: "Which 2010 to 2015 Toyota Camrys arrived at Pick-n-Pull yards near ZIP 95843 this week, and what rows are they in?" Each vehicle is charged at the prices below, so give the assistant a result limit.

### What does the output look like?

Two vehicle records from a 2026-09-30 cloud run for Acura MDX (shortened):

```json
[
  {
    "id": 7973326,
    "recordType": "vehicle",
    "vin": "2HNYD2H62CH530637",
    "year": 2012,
    "make": "Acura",
    "model": "MDX",
    "trim": "6-Spd AT w/Tech Package",
    "engine": "3.7L V6 SOHC 24V",
    "transmission": "6-Speed Automatic",
    "color": "BLACK",
    "row": "71",
    "dateAdded": "2026-09-30T00:00:00+00:00",
    "barCodeNumber": "B8387176",
    "yardName": "PICK-n-PULL Rancho Cordova",
    "yardCity": "Rancho Cordova",
    "yardState": "California",
    "yardZip": "95742",
    "url": "https://row52.com/Vehicle/Index/2HNYD2H62CH530637"
  },
  {
    "id": 7969062,
    "recordType": "vehicle",
    "vin": "2HNYD28337H513664",
    "year": 2007,
    "make": "Acura",
    "model": "MDX",
    "trim": "Tech Package",
    "engine": "3.7L V6 SOHC 24V",
    "transmission": "5-Speed Automatic",
    "color": "WHITE",
    "row": "57",
    "dateAdded": "2026-09-29T00:00:00+00:00",
    "yardName": "PICK-n-PULL Dallas South",
    "yardAddress": "5301  South 2nd Ave",
    "yardPhone": "2144219193",
    "yardHours": "Mon-Fri 9:00 am - 5:00 pm,   Sat-Sun 8:00 am - 5:00 pm",
    "imageUrl": "https://cdn.row52.com/images/5c17ceb9-0b67-4305-848e-13f2e006caf5.JPG",
    "partsPullersCount": 1,
    "url": "https://row52.com/Vehicle/Index/2HNYD28337H513664"
  }
]
```

### How much does Pick-n-Pull inventory data cost?

The Actor uses pay-per-event pricing, and platform usage is included in the event prices. Each vehicle or yard saved to the default dataset is one charged event.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM / DIAMOND |
|---|---:|---:|---:|---:|---:|
| Vehicle or yard result (one dataset row) | USD 0.003 | USD 0.002925 | USD 0.00285 | USD 0.0024 | USD 0.0024 |
| Actor start (per started GB of allocated memory) | USD 0.006251 | USD 0.006094 | USD 0.005938 | USD 0.005 | USD 0.005 |

The Actor runs with at most 1,024 MB of memory, so each run has one start event. Worked totals on the FREE tier:

- 10 vehicles (the prefilled input): 10 × USD 0.003 + USD 0.006251 = **USD 0.0363**
- 100 vehicles: 100 × USD 0.003 + USD 0.006251 = **USD 0.3063** (USD 0.245 on GOLD)
- Full yard directory of 70 yards: 70 × USD 0.003 + USD 0.006251 = **USD 0.2163**

A search that matches nothing finishes with `outcome: "EMPTY"` and costs only the start event.

### FAQ

**How fresh is the inventory?** Each run reads Row52 live, so you get what Row52 shows at run time. `dateAdded` tells you when each car arrived; yards remove cars without notice, so check before you drive.

**How fast is it?** A 2026-09-30 cloud run returned 15 Acura MDX records with full details in about 6 seconds. Turning off `includeVehicleDetails` skips the detail request per car and returns fewer fields.

**How many vehicles can one run return?** Up to 5,000 (`maxResults`). The run stops at that limit or when the search has no more pages. Duplicate VINs within a run are removed.

**Does it cover every junkyard in the US?** No. It covers the yards listed on Row52: 70 yards in 18 US states and two Canadian provinces on 2026-10-26, almost all Pick-n-Pull. Other chains are not included.

**Do I need a Row52 account or a proxy?** No. The Actor reads public pages without logging in and connects directly. There is no proxy setting to configure or pay for.

**How do I search all vehicles near a ZIP code?** Leave `make` and `model` empty and set `zipCode` and `distance`. The input form pre-fills Acura MDX as an example, so clear those fields first.

**Can I schedule it to watch for new arrivals?** Yes. Use an Apify schedule with `sort: "dateadded"` and a small `maxResults`, then compare VINs between runs.

### Related Actors

- [Copart Public Search Scraper — Auction Lots](https://apify.com/muhammadafzal/copart-public-search-scraper)
- [Cars For Sale Scraper](https://apify.com/muhammadafzal/cars-for-sale-scraper)
- [RevZilla Product Scraper — Prices & Stock](https://apify.com/muhammadafzal/revzilla-product-scraper)
- [Shopify Product Scraper](https://apify.com/muhammadafzal/shopify-product-scraper) for parts stores that run on Shopify

### Legal and data use

The Actor reads publicly available inventory pages and returns factual vehicle and yard information with a link to the source. Row52 and Pick-n-Pull are trademarks of their owners; this Actor is independent and not endorsed by them. Follow the source's terms and applicable law, and do not use the data to harass yard staff or other users.

Last verified: 2026-10-27

# Actor input Schema

## `searchMode` (type: `string`):

Select search mode. Choose 'vehicles' to search salvage yard vehicle inventory, 'yards' to scrape all Pick-n-Pull salvage yard locations, or 'vin' for direct VIN lookup.

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

Use this to search one vehicle make, for example 'Toyota' or 'Honda'; the name is resolved to the Row52 make ID. Leave empty to search all makes, for example for a ZIP-only search.

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

Use this to narrow the make to one model, for example 'Camry' or 'F-150'. If the name does not match a model of the chosen make, all models of that make are searched. Leave empty to search all models.

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

Vehicle model year (e.g. '2012') or range (e.g. '2010-2015'). Leave empty to match all years.

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

Vehicle Identification Number (full 17-character or partial VIN). Example: '2HNYD2H62CH530637'.

## `locationName` (type: `string`):

Name or city of the Pick-n-Pull yard (e.g. 'Rancho Cordova', 'San Jose', 'Antelope'). Automatically resolved to location ID.

## `locationId` (type: `integer`):

Official Row52 yard ID (e.g. 66 for Rancho Cordova, 39 for Antelope). Leave 0 to search all yards.

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

Use this to find vehicles at yards near a ZIP code, for example '95843'. Combine with Search Radius. Clear Vehicle Make and Vehicle Model to search all vehicles near the ZIP code.

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

Radius in miles around the specified ZIP code (e.g. 20, 50, 100, 250, 500).

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

Sort results by date added to yard, year, make, model, or yard.

## `sortDirection` (type: `string`):

Sort direction: descending (newest/highest first) or ascending.

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

When enabled, filters for vehicles that have photos available.

## `includeVehicleDetails` (type: `boolean`):

When enabled, fetches full vehicle specifications (engine, transmission, trim, color, barcode, high-res photos, and pullers count).

## `maxResults` (type: `integer`):

Maximum number of vehicles or yards to scrape.

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

Direct Row52 URLs to scrape (search URLs or vehicle detail URLs, e.g. 'https://row52.com/Search?MakeId=67\&ModelId=960' or 'https://row52.com/Vehicle/Index/2HNYD2H62CH530637' or 'https://row52.com/Yards/').

## Actor input object example

```json
{
  "searchMode": "vehicles",
  "make": "Acura",
  "model": "MDX",
  "locationId": 0,
  "distance": 50,
  "sort": "dateadded",
  "sortDirection": "desc",
  "hasImage": false,
  "includeVehicleDetails": true,
  "maxResults": 10,
  "startUrls": []
}
```

# Actor output Schema

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

Schema-validated salvage yard vehicles, parts details, row locations, and yard facility records.

# 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 = {
    "searchMode": "vehicles",
    "make": "Acura",
    "model": "MDX",
    "locationId": 0,
    "distance": 50,
    "sort": "dateadded",
    "sortDirection": "desc",
    "hasImage": false,
    "includeVehicleDetails": true,
    "maxResults": 10,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/row52-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 = {
    "searchMode": "vehicles",
    "make": "Acura",
    "model": "MDX",
    "locationId": 0,
    "distance": 50,
    "sort": "dateadded",
    "sortDirection": "desc",
    "hasImage": False,
    "includeVehicleDetails": True,
    "maxResults": 10,
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/row52-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 '{
  "searchMode": "vehicles",
  "make": "Acura",
  "model": "MDX",
  "locationId": 0,
  "distance": 50,
  "sort": "dateadded",
  "sortDirection": "desc",
  "hasImage": false,
  "includeVehicleDetails": true,
  "maxResults": 10,
  "startUrls": []
}' |
apify call muhammadafzal/row52-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/row52-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/UQ3WBC1mJC3TstEYV/builds/4awzQDykhg6cszIKh/openapi.json