# INFINITI Models, Trims & MSRP Scraper (`automation-lab/infiniti-configurations-msrp-scraper`) Actor

Export current US INFINITI models and trims with manufacturer keys, MSRP, destination charges, update timestamps, images, and source/build URLs.

- **URL**: https://apify.com/automation-lab/infiniti-configurations-msrp-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.39 / 1,000 trim extracteds

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?

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

## INFINITI Models, Trims & MSRP Scraper

Export current US-market **INFINITI vehicle configurations** as clean trim-level records.
The Actor discovers current models from INFINITI USA, reads the manufacturer's published pricing data, and returns model years, model and grade keys, MSRP, destination charges, source timestamps, images, and source/build URLs.

Use it for repeatable automotive catalog snapshots and pricing analysis without manually opening every vehicle page.
It does not simulate arbitrary configurations or promise interactive option compatibility.

### What does this INFINITI scraper do?

The Actor performs a bounded, source-specific workflow:

1. Opens the official INFINITI USA current-vehicle lineup.
2. Discovers current model-year vehicle pages.
3. Reads each page's manufacturer-provided trim pricing data.
4. Normalizes model, grade, version, and price fields.
5. Applies optional model and model-year filters.
6. Saves one dataset item per published trim.

The default input is ready to run.
You can also supply a specific supported vehicle detail URL for a smaller export.

### Who is it for?

#### Automotive market intelligence teams

Create timestamped snapshots of current trim identities and advertised starting prices.
Compare datasets from scheduled runs in your own database or BI tool.

#### Dealer and OEM analysts

Track model-year, grade, MSRP, and destination-charge changes from the manufacturer surface.
Use source keys to join records across recurring exports.

#### Data engineers

Feed normalized catalog rows into spreadsheets, warehouses, dashboards, or change-detection pipelines.
Use direct dataset API links rather than parsing vehicle-page HTML downstream.

#### Researchers

Export a current manufacturer catalog with source URLs and retrieval timestamps for reproducible analysis.

### Why use this Actor?

- **Trim-level output:** one useful row per published grade, rather than one row per web page.
- **Manufacturer identifiers:** includes model, grade, and version keys exposed by the source.
- **Transparent prices:** keeps MSRP and destination charge separate and also calculates their sum.
- **Traceable records:** every item carries source, build, image, source-update, and extraction URLs/timestamps.
- **Focused scope:** filters work for both discovered lineup pages and supplied model pages.
- **Low-overhead HTTP extraction:** no browser or automatic paid proxy fallback is used.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `modelYear` | Published model year |
| `model` | Model name, such as `QX60` |
| `modelKey` | Source model-year key |
| `modelCode` | Manufacturer model code |
| `trim` | Normalized grade or trim name |
| `gradeKey` | Manufacturer grade key |
| `versionKey` | Manufacturer version key |
| `msrp` | Published starting MSRP before destination |
| destinationCharge | Published destination and handling charge |
| totalStartingPrice | MSRP plus destination charge |
| `currency` | `USD` for this US-market source |
| `sourceUpdatedAt` | Update timestamp embedded with source pricing |
| `scrapedAt` | Extraction time in ISO 8601 format |
| `imageUrl` | Manufacturer-hosted model image, when exposed |
| `sourceUrl` | Official vehicle detail page |
| `buildUrl` | Official model-scoped build-and-price entry URL |

All prices are manufacturer-published starting figures.
Retailers set actual prices, and taxes, title, license, accessories, and optional equipment may be additional.

### Getting started

1. Open the Actor in Apify Console.
2. Keep the prefilled current-lineup URL for a complete snapshot.
3. Optionally add model names or model years.
4. Set `maxItems` high enough for the expected trim count.
5. Click **Start**.
6. Open the **Dataset** tab to inspect or export results.
7. Schedule the Task if you need recurring snapshots.

A first run with the prefilled input usually returns a small current catalog, not thousands of listings.
Each result is a published manufacturer trim.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | current lineup | Optional official `infinitiusa.com` lineup or vehicle pages |
| `models` | string array | all | Case-insensitive model names such as `QX60` |
| `modelYears` | integer array | all current | Model years from 2020 through 2100 |
| `maxItems` | integer | `100` | Maximum trim records, from 1 through 500 |

Only HTTPS pages on `infinitiusa.com` are accepted.
Unsupported domains fail before extraction.
Filters apply identically to supplied detail pages and lineup discovery.

#### Complete current lineup

```json
{
  "startUrls": [
    { "url": "https://www.infinitiusa.com/vehicles/new-vehicles.html" }
  ],
  "maxItems": 100
}
```

#### One model

```json
{
  "startUrls": [
    { "url": "https://www.infinitiusa.com/vehicles/crossovers/qx60.html" }
  ],
  "models": ["QX60"],
  "maxItems": 20
}
```

#### Selected models for recurring snapshots

```json
{
  "startUrls": [
    { "url": "https://www.infinitiusa.com/vehicles/new-vehicles.html" }
  ],
  "models": ["QX60", "QX80"],
  "maxItems": 50
}
```

### Output example

A dataset item follows this shape:

```json
{
  "modelYear": 2027,
  "model": "QX60",
  "modelKey": "2027-qx60",
  "modelCode": "30353",
  "trim": "LUXE AWD",
  "gradeKey": "30353-QX60_LUXE_AWD",
  "versionKey": "84217",
  "msrp": 59390,
  "destinationCharge": 1575,
  "totalStartingPrice": 60965,
  "currency": "USD",
  "sourceUpdatedAt": "2026-09-02T04:06:19Z",
  "scrapedAt": "2026-09-02T12:00:00.000Z",
  "imageUrl": "https://www.infinitiusa.com/content/dam/Infiniti/US/vehicles/QX60/2027/vehicle-profile-assets/model.png",
  "sourceUrl": "https://www.infinitiusa.com/vehicles/crossovers/qx60.html",
  "buildUrl": "https://www.infinitiusa.com/shopping-tools/build-price?models=qx60"
}
```

The default dataset remains the stable integration surface.
Download it as JSON, CSV, XML, Excel, HTML, or RSS through Apify's dataset API.

### How much does it cost to export INFINITI trims?

The Actor uses pay-per-event pricing:

- a **$0.005 start fee** per run;
- a per-item fee for each saved trim record;
- no charge for rejected, duplicate, or failed records.

At the BRONZE tier, each saved trim costs **$0.008976**.
For example, 10 trim records cost about **$0.09476** including the start fee.
A 25-record export costs about **$0.22940** at that tier.
Higher account tiers receive the decreasing per-item rates shown in Apify Console.

Source coverage is naturally small, so schedules and selected models usually matter more than a very high item limit.
Infrastructure usage is billed according to your Apify plan separately from Actor event charges where applicable.

### Recurring MSRP monitoring workflow

The Actor produces snapshots; it does not store a private cross-run history or send alerts itself.
For monitoring:

1. Save the input as an Apify Task.
2. Schedule it daily or weekly.
3. Export each run's dataset to your warehouse or automation tool.
4. Match records by `gradeKey` or by `modelKey` plus `trim`.
5. Compare the MSRP, destination-charge, and source-update fields.
6. Trigger your own notification when a field changes.

This design keeps change rules under your control.
It also avoids treating a temporary missing page as a confirmed catalog deletion.

### Integrations

#### Google Sheets and Excel

Download CSV or Excel from the dataset tab.
For recurring flows, connect Apify with Make or Zapier and append each run's records to a dated sheet.

#### Databases and warehouses

Fetch dataset items after a run and upsert them by `gradeKey`.
Keep `scrapedAt` as the observation timestamp and `sourceUpdatedAt` as manufacturer provenance.

#### Webhooks

Attach a run-succeeded webhook to notify your pipeline.
The webhook can pass the default dataset ID to your downstream processor.

#### Scheduling

Create separate Tasks for a complete lineup and for focused model monitoring.
Smaller focused runs make downstream ownership and alerts easier to reason about.

### Run with the Apify API

Replace `YOUR_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~infiniti-configurations-msrp-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"models":["QX60"],"maxItems":20}'
```

To wait for output in one request, use the synchronous dataset-items endpoint supported by the Apify API.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/infiniti-configurations-msrp-scraper').call({
  models: ['QX60', 'QX80'],
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/infiniti-configurations-msrp-scraper').call(
    run_input={'models': ['QX60'], 'maxItems': 20}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/infiniti-configurations-msrp-scraper"
```

#### Claude Desktop

Use the JSON configuration below in Claude Desktop.

#### Cursor

Add the same remote MCP server URL in Cursor's MCP settings.

#### VS Code

Add the same remote MCP server URL in your VS Code MCP configuration.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/infiniti-configurations-msrp-scraper"
    }
  }
}
```

Example prompts:

- "Export the current INFINITI QX60 trims and return MSRP plus destination charge."
- "Create a current INFINITI lineup snapshot and group the records by model year."
- "Compare these two saved INFINITI trim datasets by grade key and summarize price changes."

The comparison prompt requires you to provide both datasets to the assistant; the Actor itself returns the current snapshot only.

### Limits and responsible interpretation

- Coverage is the public US-market INFINITI USA surface.
- A record represents a published trim starting price, not local retailer inventory.
- MSRP is not a quote or guaranteed transaction price.
- Destination fees can differ by model year and source updates.
- Options, packages, colors, taxes, incentives, finance offers, and dealer add-ons are not configured.
- Interactive option compatibility is not included.
- Historical prices are not reconstructed.
- Images remain hosted by INFINITI and may change or expire.
- A source redesign can require an Actor update.

Use `sourceUrl`, `sourceUpdatedAt`, and `scrapedAt` when presenting data to others.
Do not imply that an older snapshot is still current.

### Reliability and failure behavior

The Actor retries temporary network failures, HTTP 429 responses, and source 5xx responses up to three times.
It does not blindly retry stable invalid-page errors.
If a requested source page no longer exposes recognizable model or pricing data, the run fails clearly instead of returning a misleading successful empty dataset.

A valid filter with no current matches succeeds with zero records and logs that outcome.
An unsupported domain, malformed year, or invalid limit fails input processing.

No automatic residential proxy or browser fallback is enabled.
That keeps normal runs lightweight and prevents surprise proxy transfer costs.

### Tips for stable automation

- Prefer the official lineup URL instead of maintaining guessed vehicle paths.
- Match recurring records by manufacturer keys, not array position.
- Keep raw snapshots before calculating changes.
- Treat a missing record as a signal to verify, not immediate proof of discontinuation.
- Use a moderate schedule; the source catalog does not need minute-by-minute polling.
- Keep `maxItems` above the current expected count so a newly added trim is not truncated.
- Filter models only when your downstream job truly needs a subset.

### Legal and responsible use

This Actor extracts publicly displayed manufacturer catalog and pricing facts.
You are responsible for complying with applicable laws, contractual obligations, website terms, and your intended use.
Do not use the output to misrepresent affiliation with INFINITI or to present MSRP as a binding sales offer.

Avoid unnecessary request frequency.
Store only the information needed for your legitimate analysis.
INFINITI names, marks, page content, and images belong to their respective owners.

### FAQ

#### Does it configure packages, colors, or options?

No.
It exports published model and trim identities and starting prices.
It does not promise interactive option compatibility or calculate arbitrary configured totals.

#### Does it include destination charges?

Yes, when published by the source.
The Actor returns the destination fee separately and calculates the total starting price as MSRP plus destination.

#### Can I monitor changes over time?

Yes, by scheduling recurring Task runs and comparing their datasets externally.
The Actor does not send alerts or maintain a cross-run history itself.

#### Why did my filter return zero records?

The requested model or year may not be in the current US lineup.
Check spelling, remove filters, and run the prefilled lineup input to inspect available values.

#### Why did the run fail instead of returning an empty dataset?

A supported page that lacks recognizable pricing data may indicate a source change or transient delivery problem.
Failing visibly protects monitoring pipelines from treating parser failure as a real empty catalog.

#### Are prices live dealer prices?

No.
They are manufacturer-published starting MSRP and destination values from the current public source.

#### Can I use a non-US INFINITI site?

Not in this version.
Input URLs are restricted to the official US source so currency and schema semantics remain consistent.

### Support

When reporting a problem, include:

- the Apify run URL;
- the exact input without secrets;
- the affected model or page URL;
- whether the issue is missing rows, changed fields, or a failed run.

Do not include API tokens in support messages.
A reproducible run helps distinguish an input mismatch from a source change.

### Related automation-lab Actors

For adjacent automotive datasets, explore the automation-lab portfolio on Apify Store.
Choose listing Actors when you need dealer or marketplace inventory; use this Actor when you need official current INFINITI trim and MSRP records.

The scopes should not be treated as interchangeable.
Manufacturer catalog rows and vehicle listings answer different buyer questions.

# Actor input Schema

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

Optional infinitiusa.com lineup or vehicle detail pages. Defaults to the current new-vehicle lineup.

## `models` (type: `array`):

Optional case-insensitive model names such as QX60 or QX80.

## `modelYears` (type: `array`):

Optional model years to include. Filters are also applied to supplied detail URLs.

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

Maximum number of trim-level records to save.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.infinitiusa.com/vehicles/new-vehicles.html"
    }
  ],
  "models": [],
  "modelYears": [],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all extracted trim 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 = {
    "startUrls": [
        {
            "url": "https://www.infinitiusa.com/vehicles/new-vehicles.html"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/infiniti-configurations-msrp-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 = {
    "startUrls": [{ "url": "https://www.infinitiusa.com/vehicles/new-vehicles.html" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/infiniti-configurations-msrp-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 '{
  "startUrls": [
    {
      "url": "https://www.infinitiusa.com/vehicles/new-vehicles.html"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/infiniti-configurations-msrp-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/infiniti-configurations-msrp-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/pUNPOmkfiUe2UUmaO/builds/3wMImit05GFGFb0dI/openapi.json