# The Zebra Scraper $0.0025💰 | Car Insurance Rates | Market Data (`ahmed_jasarevic/thezebra-scraper`) Actor

The Zebra is one of the largest U.S. auto & home insurance comparison marketplaces. Extract The Zebra car insurance quotes, auto insurance rate data, premium estimates, carrier lists, and insurance industry statistics into structured JSON for price monitoring and market research.

- **URL**: https://apify.com/ahmed\_jasarevic/thezebra-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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

## The Zebra Scraper — Car Insurance Quotes, Rates & Market Data

Extract car insurance quotes, auto/home insurance rates, carrier comparisons, premium estimates, insurance industry statistics, and carrier partner lists from The Zebra (thezebra.com) — one of the largest U.S. auto and home insurance comparison marketplaces. Build datasets for **car insurance price monitoring**, **auto insurance rate comparison**, and **insurance market research** without relying on the official API.

### Main Use Cases

- **Car insurance price monitoring** — track premium and rate changes over time on The Zebra's comparison and guide pages
- **Auto insurance rate comparison** — pull carrier-by-carrier rate data and premium estimates for cost analysis
- **Insurance market research** — collect insurance industry statistics, carrier lists, and pricing data points in one dataset
- **Insurance competitor analysis** — see how insurers (Progressive, GEICO, Allstate, Travelers, and 100+ more) position rates and coverage
- **Building an insurance carrier database** — capture carrier names, logos, and partner listings for downstream analysis
- **Home & renters insurance data** — extract rate and coverage content from The Zebra's home, renters, and life insurance pages

### How It Works

This actor makes one short Playwright browser visit to The Zebra to clear Cloudflare's challenge and obtain a `cf_clearance` cookie, then switches to fast Cheerio-based HTTP scraping over Apify residential proxies. It crawls the pages you target, extracts structured page data (headings, paragraphs, statistics, carriers, rate amounts, links), and saves each page as a clean JSON record in the default dataset. You can add or override fields with JavaScript via `extendOutputFunction` and `customMapFunction`.

### Extract Car Insurance Rate Data Without Official API Access

The Zebra does not offer a public API (no developer portal, OpenAPI spec, or SDK — integrations are enterprise-negotiated only). This actor is the practical way to collect The Zebra's published insurance comparison content and rate statistics as structured data, on your own schedule.

### Build Business Databases From Insurance Comparison Pages

Instead of manually copy-pasting from dozens of The Zebra guide and comparison pages, run this actor once or on a recurring schedule to assemble a clean, queryable dataset of insurance pages, carrier lists, and rate data points.

### Input

The Zebra Scraper is configured through an input JSON with the following fields:

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array of `{ url }` | No | The Zebra homepage + auto/homeowners/renters/average-cost pages | URLs to start scraping from; crawler stays on thezebra.com within auto/home/renters/life/health paths |
| `maxResults` | integer | No | `100` | Maximum number of pages (dataset items) to scrape; the actor stops after reaching this limit |
| `proxyConfiguration` | object | No | Apify residential proxies | Proxy settings for bot-detection bypass |
| `extendOutputFunction` | string | No | `""` | JavaScript expression receiving `($, item)`; returns extra/override fields |
| `customMapFunction` | string | No | `""` | JavaScript function receiving `item`; returns the mapped item |

### Output

Each dataset item is one scraped The Zebra page:

| Field | Type | Description |
|---|---|---|
| `url` | string | URL of the scraped page |
| `title` | string | Page title or first H1 heading |
| `headings` | array | H1, H2, H3 headings extracted from the page |
| `paragraphs` | array | Paragraph text content from the page |
| `lists` | array | List item text extracted from the page |
| `links` | array of `{ text, href }` | Hyperlinks found on the page |
| `images` | array of `{ src, alt }` | Images found on the page |
| `statistics` | array | Insurance statistics and data points (dollar/percent figures about rates, cost, premiums, savings) |
| `carriers` | array of `{ name, logo }` | Insurance carriers and partners detected on the page |
| `rateInfo` | array | Dollar amounts and pricing data found on the page |
| `structuredData` | array | JSON-LD structured data embedded in the page |

### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.thezebra.com/auto-insurance/" },
    { "url": "https://www.thezebra.com/homeowners-insurance/" }
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example Output

```json
{
  "url": "https://www.thezebra.com/auto-insurance/",
  "title": "Compare Auto Insurance Rates",
  "headings": ["Compare Auto Insurance Quotes", "Top Car Insurance Companies"],
  "paragraphs": ["The Zebra compares real quotes side by side from top companies."],
  "lists": ["Progressive", "GEICO", "Allstate"],
  "statistics": ["The average cost of car insurance is $1,834 per year."],
  "carriers": [
    { "name": "Progressive Insurance", "logo": "https://www.thezebra.com/img/progressive.png" }
  ],
  "rateInfo": ["$125/month", "$1,500/year"],
  "structuredData": [{ "@type": "Organization", "name": "The Zebra" }]
}
```

### Integrations & Automation

- **Apify API** — call the actor programmatically from your own app or script.
- **Webhooks** — get notified when a run finishes and push new items to your system.
- **Zapier / Make** — connect scraped insurance data to spreadsheets, databases, or BI dashboards.

Recommended schedule: run **weekly** for car insurance price monitoring and rate tracking, and **monthly** to refresh insurance market research and carrier databases.

### Related Actors

- [Coverfox Scraper — Indian Insurance Comparison Plans](https://apify.com/crawlerbros/coverfox-scraper)
- [MoneySuperMarket Scraper — UK Financial Comparison](https://apify.com/studio-amba/moneysupermarket-scraper)
- [Bankrate Financial Rates Scraper](https://apify.com/crawlerbros/bankrate-scraper)
- [Comparis Scraper — Swiss Insurance & Telecom Comparison](https://apify.com/studio-amba/comparis-scraper)

### FAQ

#### Why use this actor instead of the official API?

The Zebra does not provide a public API. There is no developer portal, no OpenAPI reference, and no SDK — integrations are only done through enterprise partnership deals. This actor is the practical way to extract The Zebra's published insurance comparison content and rate data as structured JSON.

#### What are alternatives to The Zebra for car insurance rate data?

The Zebra is one of several major U.S. auto/home insurance comparison marketplaces. Comparable sites include Insurify, Compare.com, NerdWallet, Policygenius, EverQuote, and Jerry. This actor focuses specifically on The Zebra's content; other comparison sites can be covered by their own scrapers.

#### What car insurance data does The Zebra publish?

The Zebra publishes average car insurance rates by state and city, carrier-by-carrier premium comparisons, premium estimates, coverage guidance, and insurance industry statistics. Its rate estimates are sourced from rate filings via Quadrant Information Services and from anonymized real customer quote data.

#### How much does the average cost of car insurance vary by state?

Average car insurance costs differ sharply by state — for example Florida, Louisiana, and Missouri are among the most expensive, while Vermont, New Hampshire, and Idaho are the least expensive. This actor can capture The Zebra's state rate content for your own analysis.

#### How can I build an insurance carrier or price database?

Use `startUrls` to target The Zebra's auto, home, renters, life, and health comparison pages, set a sensible `maxResults`, and run on a weekly or monthly schedule. The `carriers`, `statistics`, and `rateInfo` fields give you per-carrier names, logos, and pricing data points.

#### Can I extend or transform the output?

Yes. `extendOutputFunction` lets you add or override fields with JavaScript against the scraped item and the Cheerio `$` object, and `customMapFunction` lets you reshape each output item to your own schema.

### SEO Keywords

thezebra scraper, thezebra data extraction, car insurance quotes scraping, auto insurance rate comparison, car insurance price monitoring, insurance market research, car insurance rate data, insurance industry statistics, insurance carrier database, insurance competitor analysis, average cost of car insurance, cheapest car insurance by state, car insurance rates by state, insurance comparison data, insurance premium estimates, home insurance comparison data, renters insurance rate data, insurance carrier list, insurance rates scraping, insurance market data

### For AI Agents & LLM Apps

This actor is callable via the **Apify MCP server** and the **Apify API**. Returns one JSON record per scraped The Zebra page, containing page content, carrier lists, and rate statistics.

Minimal working input (smallest valid run):

```json
{
  "startUrls": [{ "url": "https://www.thezebra.com/auto-insurance/" }],
  "maxResults": 10
}
```

To scrape a broader comparison scope, add multiple library pages:

```json
{
  "startUrls": [
    { "url": "https://www.thezebra.com/auto-insurance/" },
    { "url": "https://www.thezebra.com/homeowners-insurance/" }
  ],
  "maxResults": 50
}
```

**Output fields:** `url`, `title`, `headings`, `paragraphs`, `lists`, `links`, `images`, `statistics`, `carriers`, `rateInfo`, `structuredData`.

**Behaviors an agent should know:**

- `maxResults` is the cost-relevant cap — it limits how many pages are scraped (defaults to 100 when unset). Set it to bound cost; the actor is billed per result ($0.0025/item) plus a run start cost.
- `startUrls` overrides the built-in default page list (homepage + auto/homeowners/renters/average-cost pages). If you omit it, the defaults are used.
- The crawler only stays on thezebra.com within auto/home/renters/life/health paths — supply specific `/states/` or guide URLs via `startUrls` to target them.
- `extendOutputFunction` receives the Cheerio `$` object and the current `item`; `customMapFunction` transforms each output item. Both are optional.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by The Zebra** (thezebra.com). It only accesses publicly available pages on the site — it does not bypass logins and does not solve CAPTCHAs. Users are responsible for complying with The Zebra's Terms of Service and applicable laws. Do not use extracted personal contact data for unsolicited commercial outreach. This information is provided for transparency and is not legal advice.

# Actor input Schema

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

List of URLs to start scraping from. Defaults to thezebra.com homepage and key insurance pages.

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

Maximum number of pages to scrape. The actor will stop after reaching this limit.

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

Proxy settings for bypassing bot detection. Uses Apify residential proxies by default.

## `extendOutputFunction` (type: `string`):

Add or override output fields using JavaScript expressions. Receives an object with the data scraped so far and the Cheerio `$` object. Must return an object with the fields to add or override.

## `customMapFunction` (type: `string`):

Function to map each item to a different format. Receives the scraped item and must return the mapped item.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.thezebra.com"
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "extendOutputFunction": "",
  "customMapFunction": ""
}
```

# Actor output Schema

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

Dataset containing all scraped page data

# 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": [
        "https://www.thezebra.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/thezebra-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": ["https://www.thezebra.com"] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/thezebra-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": [
    "https://www.thezebra.com"
  ]
}' |
apify call ahmed_jasarevic/thezebra-scraper --silent --output-dataset

```

## MCP server setup

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