# Ford US Inventory Scraper - Trim Counts & Pricing by ZIP (`rastriq/ford-us-inventory-http`) Actor

Ford USA new-car inventory by ZIP and trim: stock counts, base MSRP, destination charge and nearest dealer. HTTP-only, JSON/CSV/Excel export.

- **URL**: https://apify.com/rastriq/ford-us-inventory-http.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** Automation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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?

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

## Ford US Inventory Scraper - Trim Counts, MSRP & Dealers by ZIP

**Ford US Inventory Scraper** returns new Ford inventory counts per trim and ZIP code from Ford's public JSON endpoints (ford.com), together with catalog base price, destination charge, MSRP discount signal and the nearest Ford dealer. It is HTTP-only (no browser), so runs are fast and cheap, and results export to JSON, CSV, Excel or the Apify API.

Note: counts are aggregated per trim within a 50-mile radius of the ZIP (stages: on lot, in transit, in production). This actor does not return individual VINs or per-vehicle listings.

### Why use Ford US Inventory Scraper?

- **Official Ford source**: data comes from ford.com's own inventory and catalog endpoints, not from third-party aggregators.
- **Trim-level granularity**: one row per model, year, trim and ZIP, ready for pivot tables and dashboards.
- **Market presets**: national sample, 25 metro markets, or regional presets (Northeast, Southeast, Midwest, Texas, West Coast), or your own ZIP list.
- **Pricing signals** in the same row: base price, destination and delivery charge, MSRP discount.
- **Cheap to run**: no browser or residential proxy needed. Most marketplace scrapers on the Store return individual listings from third-party sites; this one focuses on Ford OEM stock availability.
- **Safe cost control**: `maxResults` cap plus automatic stop when your spending limit is reached.

### Ford US Inventory Scraper use cases

- Competitive and market intelligence for automotive analysts and OEM rivals
- Dealer groups and fleet buyers tracking supply of specific trims by region
- Supply and days-of-stock monitoring for EV and truck lines (Mach-E, F-150, Maverick)
- Feeding BI dashboards, Google Sheets or data warehouses on a schedule

### How to use Ford US Inventory Scraper

1. Open the actor and keep the defaults (Bronco Sport, 2026, national sample, 20 rows).
2. Choose a **Market scope** or a **Custom ZIP list** under Advanced settings.
3. Select **Model families** and **Model years** (or "All").
4. Set **Max results** (0 = no limit) and click **Start**.
5. Download the dataset, or call the actor via API, Make, Zapier, n8n or MCP.

#### Example input

```json
{
  "marketScope": "national_sample",
  "modelFamilies": ["bronco-sport"],
  "yearCoverage": ["2026"],
  "maxResults": 20,
  "includeDealers": true
}
```

#### Example output

```json
{
  "recordType": "inventory_by_trim",
  "marketScope": "national_sample",
  "postalCode": "10001",
  "geoKey": "...",
  "state": "NY",
  "city": "New York",
  "dealerName": "Example Ford",
  "dealerPACode": "12345",
  "distanceMiles": 4.2,
  "make": "Ford",
  "modelFamilyName": "Bronco Sport",
  "model": "Bronco Sport",
  "year": 2026,
  "trimId": "F12-BIGBEND",
  "trimName": "Big Bend",
  "inventoryCount": 37,
  "vehicleStageFilter": ["onlot", "intransit", "inproduction"],
  "specialEventBasePrice": 33000,
  "destinationDeliveryCharge": 1495,
  "scrapedAt": "2026-10-10T10:00:00+00:00"
}
```

Values are illustrative; actual data depends on Ford's live response. Price fields can be null for some model-year-market combinations.

#### Sample output from a real run

One row from a real run (national sample, Bronco Sport 2026). Note that `specialEventBasePrice` and `specialEventMSRPDiscount` are `null` here:

```json
{
  "recordType": "inventory_by_trim",
  "marketScope": "national_sample",
  "postalCode": "10001",
  "geoKey": "US|F13T|13T501|19B501|13|19|BOSFL2|FFLSTA|FLXSTA|F13-NY|L19-NY|NYFLX|PITFX2",
  "state": "NY",
  "city": "NEW YORK",
  "regionTypes": [
    {
      "type": "FDAF",
      "displayName": "TriState Ford Dealers"
    },
    {
      "type": "LMDA",
      "displayName": "New York LMDA"
    },
    {
      "type": "DMA",
      "displayName": "New York LMDA"
    },
    {
      "type": "Marketing",
      "displayName": "New York"
    }
  ],
  "dealerName": "United Ford",
  "dealerPACode": "03471",
  "dealerUrl": "https://www.unitedfordnj.com",
  "distanceMiles": 3.58,
  "make": "Ford",
  "modelFamilyKey": "bronco-sport",
  "modelFamilyName": "Bronco Sport",
  "model": "Bronco Sport",
  "year": 2026,
  "trimId": "F12-BIGBEND",
  "trimName": "Big Bend®",
  "inventoryCount": 842,
  "vehicleStageFilter": [
    "onlot",
    "intransit",
    "inproduction"
  ],
  "catalogId": "WANAB-CHD-2026-BroncoSport",
  "vehicleLineCode": "F1226",
  "specialEventBasePrice": null,
  "destinationDeliveryCharge": 1995,
  "specialEventMSRPDiscount": null,
  "scrapedAt": "2026-10-10T21:34:30.360453+00:00",
  "sourceEndpoints": [
    "/cxservices/geo/PostalCodes.json",
    "/cxservices/dealer/Dealers.json",
    "/aemservices/common/api/attributes/proxy",
    "/cxservices/inventory/CountByTrim.json"
  ]
}
```

### Ford US Inventory Scraper input parameters

All inputs are optional.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `marketScope` | string | `national_sample` | `national_sample` (10 ZIPs across the US), `all_supported_markets` (25 metro ZIPs), regional presets `northeast`, `southeast`, `midwest`, `texas`, `west_coast`, or `custom` |
| `modelFamilies` | array | `["bronco-sport"]` (form prefill) | One or more of `bronco-sport`, `bronco`, `escape`, `explorer`, `f-150`, `maverick`, `mustang`, `mustang-mach-e`, `ranger`, `super-duty`, or `ALL` |
| `yearCoverage` | array | `["2026"]` (form prefill) | `2024`, `2025`, `2026` or `ALL` |
| `maxResults` | integer | `0` (form prefill: 20) | Stop after this many output rows (each row = one trim in one ZIP). Billed per row. `0` or empty = no cap |
| `includeDealers` | boolean | `true` | Adds nearest dealer name, PA code and distance to each row, and stores a dealer coverage snapshot in the key-value store |
| `customPostalCodes` | array | empty | US ZIP codes. Only used when `marketScope` is `custom` |
| `customModels` | array (JSON) | empty | Advanced override for ad hoc model-year combinations. Each object needs `year` and `model`; optional `make` (default Ford) and `trimIds` |
| `trimConcurrency` | integer | `5` | Parallel trim-level inventory calls (1 to 20). Lower values are gentler; 10 to 20 are faster but raise the risk of transient errors |
| `proxyConfiguration` | object | Apify datacenter proxy pre-selected | Optional. Ford's public endpoints usually work without a proxy; clear it to run without one |

Custom ZIP list, two truck lines, two model years:

```json
{
  "marketScope": "custom",
  "customPostalCodes": ["10001", "90001", "33130"],
  "modelFamilies": ["f-150", "maverick"],
  "yearCoverage": ["2025", "2026"],
  "maxResults": 100,
  "includeDealers": true
}
```

Ad hoc model-year override for one trim:

```json
{
  "marketScope": "national_sample",
  "customModels": [{ "year": 2026, "model": "Bronco Sport", "trimIds": ["F12-BIGBEND"] }],
  "maxResults": 20
}
```

### Output fields

| Field | Type | Description |
|---|---|---|
| `postalCode`, `state`, `city`, `geoKey` | string | ZIP and resolved Ford market |
| `dealerName`, `dealerPACode`, `dealerUrl`, `distanceMiles` | string/number | Nearest Ford dealer (if enabled) |
| `model`, `year`, `trimId`, `trimName` | string/int | Vehicle identifiers |
| `inventoryCount` | integer | Trim stock within 50 miles of the ZIP |
| `specialEventBasePrice` | number | Catalog base price (USD) |
| `destinationDeliveryCharge` | number | Destination charge (USD) |
| `specialEventMSRPDiscount` | number | MSRP discount signal |
| `catalogId`, `vehicleLineCode` | string | Ford catalog identifiers |
| `scrapedAt` | string | UTC timestamp |

Extra outputs in the key-value store: `RUN_SUMMARY`, `MARKET_CONTEXTS`, `DEALER_COVERAGE`, `MODEL_CATALOGS`.

Real rows also carry `recordType` (`inventory_by_trim`), `marketScope`, `regionTypes` (Ford marketing regions for the ZIP), `modelFamilyKey`, `modelFamilyName`, `make`, `vehicleStageFilter` and `sourceEndpoints`.

### How much does it cost to scrape Ford US inventory?

Pay per result (pay-per-event): you pay for each output row, with volume discounts on higher Apify plans. See the pricing box on this page for the exact rate. Example: 10 ZIPs x 1 model x 1 year x about 5 trims is about 50 rows. Platform compute is included in the per-result price.

Pay-per-event pricing with one event, **Result** ("One trim inventory row saved to the default dataset"). The price per row depends on your Apify discount tier:

| Apify discount tier | Price per result |
|---------------------|------------------|
| Free | $0.0060 |
| Bronze | $0.0052 |
| Silver | $0.0045 |
| Gold, Platinum, Diamond | $0.0040 |

There is no separate Actor Start charge in this Actor's pricing events.

Worked examples:

- **About 50 rows** (10 ZIPs x 1 model x 1 year x about 5 trims): 50 x $0.0060 = **$0.30** on Free, 50 x $0.0040 = **$0.20** on Gold.
- **About 125 rows** (25 metro ZIPs x 1 model x 1 year x about 5 trims): 125 x $0.0060 = **$0.75** on Free, 125 x $0.0040 = **$0.50** on Gold.
- **1,000 rows:** **$6.00** on Free, **$5.20** on Bronze, **$4.50** on Silver, **$4.00** on Gold.

### Ford US Inventory Scraper FAQ

**Is it legal?** The actor only reads publicly available, non-personal inventory counts and catalog data. You are responsible for complying with Ford's terms of use and applicable law in your use of the data.

**Does it return VINs or individual cars?** No, only aggregated counts per trim and ZIP.

**How often should I run it?** Daily or weekly on a schedule; inventory moves slowly.

**How do I limit cost?** Set `maxResults` and the run's maximum charge; the actor stops cleanly when either is reached.

**Integrations?** Apify API, Make, Zapier, n8n, Google Sheets, webhooks and MCP.

**How much does Ford US Inventory Scraper cost?** $0.006 per row on the Free tier down to $0.004 per row on Gold and above; 1,000 rows cost between $4.00 and $6.00. There is no Actor Start fee. See the pricing section above.

**Which models, years and ZIPs are supported?** Bronco Sport, Bronco, Escape, Explorer, F-150, Maverick, Mustang, Mustang Mach-E, Ranger and Super Duty for model years 2024 to 2026, across the market presets or your own ZIP list. For other model-year combinations try `customModels`; for another model or market, open an issue.

### Support

Found a bug or need another Ford model or market? Open an issue from the actor page.

### Related Rastriq actors

- [Ford Europe Car Prices & Trims Scraper](https://apify.com/rastriq/ford-europe-car-prices)
- [Toyota Europe Inventory & Prices](https://apify.com/rastriq/toyota-europe-inventory)
- [SEAT Spain Stock Scraper - New Car Dealer Inventory](https://apify.com/rastriq/seat-spain-stock-scraper)
- [Skoda Stock & Pricing Scraper](https://apify.com/rastriq/skoda-stock-pricing)
- [Audi Middle East Dealer Inventory Scraper](https://apify.com/rastriq/audi-me-stock-scraper)

# Actor input Schema

## `marketScope` (type: `string`):

Choose the geographic coverage for your run.<br><br>• <b>National sample</b> — 10 ZIPs across the US (fast, cheap)<br>• <b>All supported markets</b> — 25 metro ZIPs for broad coverage<br>• <b>Regional presets</b> — Northeast, Southeast, Midwest, Texas, West Coast<br>• <b>Custom ZIP list</b> — paste your own ZIPs in the Advanced section below<br><br>💡 Start with <b>National sample</b> for your first run.

## `modelFamilies` (type: `array`):

Select one or more Ford model families to monitor. Choose <b>All supported models</b> for a full portfolio sweep.<br><br>Currently supported: Bronco Sport, Bronco, Escape, Explorer, F-150, Maverick, Mustang, Mustang Mach-E, Ranger, Super Duty.

## `yearCoverage` (type: `array`):

Select one or more model years. Choose <b>All supported years</b> for full year-over-year coverage.

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

Stop after this many output rows (each row = one trim in one ZIP). Billed per row, so use 10-50 for test runs. Set <code>0</code> or leave empty for unlimited.

## `includeDealers` (type: `boolean`):

Adds nearest dealer name, PA code, and distance to each inventory row. Also stores a dealer coverage snapshot in the key-value store.<br><br>💡 Disable to speed up runs if you only need inventory counts.

## `customPostalCodes` (type: `array`):

Enter US ZIP codes for custom market coverage. <b>Only used</b> when Market scope is set to <b>Custom ZIP list</b>.<br><br>Example: <code>10001</code>, <code>90001</code>, <code>33130</code>

## `customModels` (type: `array`):

Advanced override for unsupported or ad hoc Ford model-year combinations. Each object needs <code>year</code> and <code>model</code>. Optional: <code>make</code> (default Ford), <code>trimIds</code> (specific trims only).<br><br>Example:<br><code>\[{"year": 2026, "model": "Bronco Sport", "trimIds": \["F12-BIGBEND"]}]</code>

## `trimConcurrency` (type: `integer`):

How many trim-level inventory calls run in parallel.<br><br>• <b>1–3</b> — gentle, less likely to get rate-limited<br>• <b>5</b> — balanced (default)<br>• <b>10–20</b> — fast, but increases risk of transient errors

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

Optional. Ford's public endpoints usually work without a proxy. Datacenter Apify Proxy is pre-selected for resilience; clear it to run without a proxy.

## Actor input object example

```json
{
  "marketScope": "national_sample",
  "modelFamilies": [
    "bronco-sport"
  ],
  "yearCoverage": [
    "2026"
  ],
  "maxResults": 20,
  "includeDealers": true,
  "trimConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `inventoryByTrim` (type: `string`):

Structured trim-level Ford US inventory dataset. Each row contains market context, model/trim identifiers, inventory count, dealer reference, and catalog pricing signals for the selected markets, model families, and years.

## `runSummary` (type: `string`):

JSON summary of the run: markets processed, models covered, trim requests made, output rows pushed, and any errors encountered.

## `marketContexts` (type: `string`):

Resolved ZIP-to-Ford-market context records including geoKey, state, city, and Ford region descriptors for each ZIP code processed.

## `dealerCoverage` (type: `string`):

Nearest Ford dealer records for each processed ZIP code: dealer name, PA code, address, distance, specialties, and website.

## `modelCatalogs` (type: `string`):

Ford model catalog metadata snapshots: catalogId, vehicleLineCode, base price, destination charge, and MSRP discount for each model-year-market combination.

# 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 = {
    "modelFamilies": [
        "bronco-sport"
    ],
    "yearCoverage": [
        "2026"
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/ford-us-inventory-http").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 = {
    "modelFamilies": ["bronco-sport"],
    "yearCoverage": ["2026"],
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/ford-us-inventory-http").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 '{
  "modelFamilies": [
    "bronco-sport"
  ],
  "yearCoverage": [
    "2026"
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/ford-us-inventory-http --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/ford-us-inventory-http"
        }
    }
}
```

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/KOakhB0SWFoCUQwvb/builds/hbDMLWzoUhhiXAjaQ/openapi.json
