# SimpleTire Scraper (`crawlerbros/simpletire-scraper`) Actor

Scrape SimpleTire.com - search tires by size (width/ratio/diameter), by vehicle (year/make/model), or by brand. Get price, brand, rating, UTQG, warranty, and performance scores with no login or proxy required.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## SimpleTire Scraper

Scrape [SimpleTire.com](https://simpletire.com) — search tires by size (width / aspect ratio / rim diameter), by vehicle (year / make / model), or by brand. Get price, brand, customer rating, UTQG rating, warranty, load/speed rating, and SimpleTire's own performance scores (handling, durability, traction). No login, no cookies, and no paid proxy required.

### What this actor does

- **Three modes:** `byTireSize`, `byVehicle`, `byBrand`
- **Real pricing** in USD, straight from the live catalog
- **Rich specs:** UTQG treadwear rating, warranty, load index, speed rating, sidewall style, run-flat flag
- **Performance scores:** SimpleTire's SimpleScore plus handling / durability / traction sub-scores
- **Multiple images per tire:** sidetread, sidewall, full tread, tread close-up
- **Filters:** minimum rating, price range, category keyword, run-flat only
- **Empty fields are omitted** — every returned field has a real value

### Output per tire

| Field | Description |
|---|---|
| `productLine` / `title` | Tire model name, e.g. "Proxes R888R" |
| `highlight` | Promotional badge text shown on the listing, e.g. `"34% off"`, `"65k mile"` (mode=byTireSize only — not populated on byVehicle/byBrand pages) |
| `brand`, `brandLogoUrl` | Manufacturer name and logo |
| `size` | Full tire size string, e.g. `225/45ZR17` |
| `subType` | Vehicle class, e.g. `Passenger` |
| `category` | Tire type/category, e.g. `Track Competition`, `UHP Summer`, `All-Season` |
| `price`, `priceCurrency`, `salePrice` | Retail price in USD (sale price included when discounted) |
| `ratingValue`, `reviewCount` | Average customer rating (0–5) and number of reviews |
| `utqg` | Uniform Tire Quality Grade (treadwear/traction/temperature code) |
| `warranty` | Manufacturer mileage warranty |
| `speedRating`, `loadIndex`, `loadRange`, `loadSpeedRating` | Load & speed capacity specs |
| `sidewallStyle` | Blackwall / whitewall / raised-white-letter, etc. |
| `isRunFlat` | Whether the tire is run-flat |
| `simpleScore`, `handlingScore`, `durabilityScore`, `tractionScore` | SimpleTire's 0–10 performance scores |
| `sidetreadImageUrl`, `sidewallImageUrl`, `treadImageUrl`, `treadCloseupImageUrl`, `imageUrls[]` | Product photography |
| `productUrl`, `sourceUrl` | Canonical SimpleTire product page |
| `partNumber`, `productId`, `productLineId` | Internal SimpleTire catalog identifiers |
| `curationGroupId`, `curationGroupLabel` | Which curated list the tire appeared in (e.g. "Best customer rated") |
| `searchTireSize` / `searchVehicle` / `searchBrand` | Echoes the search context used to find this tire |
| `recordType`, `scrapedAt` | Always `"tire"` and a UTC timestamp |

### Input

| Field | Type | Mode | Description |
|---|---|---|---|
| `mode` | select | all | `byTireSize` (default) / `byVehicle` / `byBrand` |
| `width` | select | byTireSize | Tire section width in mm (e.g. `225`) |
| `ratio` | select | byTireSize | Aspect ratio (e.g. `45`) |
| `diameter` | select | byTireSize | Rim diameter in inches (e.g. `17`) |
| `sizeBrandFilter` | select | byTireSize | Optional: narrow to one brand |
| `make` | select | byVehicle | Vehicle manufacturer (89 makes) |
| `model` | text | byVehicle | Vehicle model, e.g. `Civic`, `Model Y`, `F-150` |
| `year` | integer | byVehicle | Model year (1980–2027) |
| `brand` | select | byBrand | Tire brand to browse |
| `minRating` | integer | all | Drop tires rated below this (0–5) |
| `minPrice` / `maxPrice` | integer | all | Price range filter (USD) |
| `category` | text | all | Keep tires whose category text contains this (case-insensitive) |
| `runFlatOnly` | boolean | all | Only emit run-flat tires |
| `maxItems` | integer | all | Hard cap on emitted records (1–300) |

#### Example: search by tire size

```json
{
  "mode": "byTireSize",
  "width": "225",
  "ratio": "45",
  "diameter": "17",
  "maxItems": 30
}
```

#### Example: search by tire size, one brand only

```json
{
  "mode": "byTireSize",
  "width": "245",
  "ratio": "50",
  "diameter": "18",
  "sizeBrandFilter": "continental",
  "maxItems": 20
}
```

#### Example: search by vehicle

```json
{
  "mode": "byVehicle",
  "make": "honda",
  "model": "civic",
  "year": 2022,
  "maxItems": 20
}
```

#### Example: browse a brand's full catalog, run-flat only

```json
{
  "mode": "byBrand",
  "brand": "bridgestone",
  "runFlatOnly": true,
  "maxItems": 50
}
```

### Use cases

- **Tire shops & installers** — compare live pricing and specs across brands for a given fitment
- **Fleet management** — bulk-check tire availability/pricing for a fleet's common sizes
- **Price monitoring** — track a brand's or size's pricing over time
- **Vehicle marketplaces** — surface "recommended tires" for a listed vehicle by year/make/model
- **Comparison shopping tools** — build a tire comparison table with UTQG, warranty, and scores
- **Automotive content** — source real specs/images for buying-guide articles

### Limitations

- **Curated top picks, not the full catalog per query.** SimpleTire's tire-size and vehicle search pages server-render a curated set of top picks (typically 15–25 tires across several editorial groups: best-rated, most popular, best warranty, etc.) rather than the complete paginated catalog (which can run into the hundreds of SKUs per size and loads via client-side interaction). `byBrand` mode returns a brand's curated catalog listing (typically 15–20 tires). This actor exposes exactly what's reliably extractable from the server-rendered page without a browser — real, accurate data, just not the full long-tail catalog.
- **Model names are free text.** SimpleTire supports 89 makes with dozens of models each (and many trims); enumerating every make→model combination isn't practical, so `model` is free text — use the exact model name as shown on SimpleTire (e.g. `Civic`, `Model Y`, `F-150`, `3 Series`).
- **Brand enum is curated, not exhaustive.** SimpleTire carries 300+ tire brands (many private-label/off-brand). The `brand` and `sizeBrandFilter` dropdowns list ~40 of the best-known brands actually sold on SimpleTire (verified against the live brand directory). Note that some premium brands with strict retail distribution agreements (e.g. Michelin, BFGoodrich) are **not** sold by SimpleTire and are therefore not in the list.
- **US-market pricing only.** SimpleTire serves the US market in USD; no international/multi-currency support.

### FAQ

**Do I need a proxy or login?** No. SimpleTire's search and catalog pages are publicly accessible; the actor uses plain HTTPS requests with no cookies or authentication.

**Why is `salePrice` sometimes missing?** It's only included when the sale price differs from the regular price — otherwise the `price` field alone represents the current price.

**What does `curationGroupId` mean?** SimpleTire organizes its top-picks pages into named groups such as "Best customer rated," "Best warranty," or "Our best deals." This field tells you which group surfaced the tire, useful for weighting results.

**Can I search by trim level (e.g. "EX Sedan")?** Not directly — SimpleTire's vehicle search operates at the year/make/model level. Trim-specific OE sizing is sometimes mentioned in on-page text but isn't part of the structured catalog data this actor extracts.

**What currency are prices in?** USD — SimpleTire is a US-only retailer.

**How current is the pricing?** Live — every run fetches the current catalog page directly from SimpleTire.

**Are the image URLs stable?** Yes — they're served from SimpleTire's own CDN (`images.simpletire.com`) and are not signed or expiring.

# Actor input Schema

## `mode` (type: `string`):

How to search for tires.

## `width` (type: `string`):

Tire section width in millimeters, e.g. 225 in 225/45R17.

## `ratio` (type: `string`):

Tire aspect (profile) ratio, e.g. 45 in 225/45R17.

## `diameter` (type: `string`):

Wheel rim diameter in inches, e.g. 17 in 225/45R17.

## `sizeBrandFilter` (type: `string`):

Narrow the tire-size search to a single brand. Leave blank to see all brands for that size.

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

Vehicle manufacturer.

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

Vehicle model name, e.g. `Civic`, `Model Y`, `F-150`. The model set is too large to enumerate reliably per-make, so this is free text — use the exact model name as shown on SimpleTire.

## `year` (type: `integer`):

Model year.

## `brand` (type: `string`):

Browse all tires SimpleTire carries from this brand.

## `minRating` (type: `integer`):

Drop tires with an average customer rating below this (1-5 stars).

## `minPrice` (type: `integer`):

Drop tires priced below this amount in USD.

## `maxPrice` (type: `integer`):

Drop tires priced above this amount in USD.

## `category` (type: `string`):

Keep only tires whose category/type text contains this (case-insensitive), e.g. `all-season`, `performance`, `winter`, `truck`, `summer`.

## `runFlatOnly` (type: `boolean`):

Only emit tires marked as run-flat.

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

Hard cap on emitted records. Note: mode=byBrand reads a curated subset of tires embedded in the brand page (typically 10-20 lines) rather than the full paginated SKU catalog; mode=byTireSize/byVehicle are scoped to a specific size/vehicle so this ceiling is rarely reached there.

## Actor input object example

```json
{
  "mode": "byTireSize",
  "width": "225",
  "ratio": "45",
  "diameter": "17",
  "sizeBrandFilter": "",
  "make": "honda",
  "model": "civic",
  "year": 2022,
  "brand": "goodyear",
  "category": "",
  "runFlatOnly": false,
  "maxItems": 30
}
```

# Actor output Schema

## `tires` (type: `string`):

Dataset containing all scraped tires.

# 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 = {
    "mode": "byTireSize",
    "width": "225",
    "ratio": "45",
    "diameter": "17",
    "sizeBrandFilter": "",
    "make": "honda",
    "model": "civic",
    "year": 2022,
    "brand": "goodyear",
    "category": "",
    "runFlatOnly": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/simpletire-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 = {
    "mode": "byTireSize",
    "width": "225",
    "ratio": "45",
    "diameter": "17",
    "sizeBrandFilter": "",
    "make": "honda",
    "model": "civic",
    "year": 2022,
    "brand": "goodyear",
    "category": "",
    "runFlatOnly": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/simpletire-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "byTireSize",
  "width": "225",
  "ratio": "45",
  "diameter": "17",
  "sizeBrandFilter": "",
  "make": "honda",
  "model": "civic",
  "year": 2022,
  "brand": "goodyear",
  "category": "",
  "runFlatOnly": false,
  "maxItems": 30
}' |
apify call crawlerbros/simpletire-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/simpletire-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CLYckikBauf3QINVh/builds/D46l9YVIGpmGO7rV6/openapi.json