The Zebra MCP server for AI agents

Let Claude, ChatGPT or your own agent read The Zebra: 8 typed functions through one MCP server. No The Zebra API key needed.

Functions
8
Sign-in
Not needed
Works with
MCP, HTTP, Node, Python

Connect

Just The Zebra

An MCP server for The Zebra alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/thezebra
Every site

One MCP server for The Zebra and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 8
  • getAutoQuotesReturns real side-by-side auto insurance rates from the carriers that will write a given driver.

    Arguments

    NameTypeRequired
    driverthezebraAutoDriverYes
    vehiclethezebraAutoVehicleYes
    statestring
    2-letter postal code.
    Yes
    zipstring
    5 digits.
    Yes
    countystring
    The county the ZIP sits in.
    Yes
    currentlyInsuredboolean
    Default true.
    No
    userPurchaseTimeframe"TODAY" | "FUTURE"
    Default "TODAY".
    No

    Returns thezebraAutoQuotes

    interface thezebraAutoQuote {
      carrier: string                       // e.g. "Progressive"
      carrierSlug: string                   // the site's own slug, e.g. "progressive"
      monthlyPremium: number                // USD per MONTH; the card's period is asserted
      sixMonthPremium: number | null        // USD per 6-month policy, where the card publishes one
      totalPremium: number | null           // USD for the whole term, never derived
      policyLengthMonths: number | null
      deductible: number | null
      coverages: string[]                   // every coverage the card lists, verbatim
    }
    
    interface thezebraAutoQuotes {
      quotes: thezebraAutoQuote[]           // cheapest monthly premium first; [] is a real answer
      // The carriers ADVERTISED beside the quotes, paid placements with no price.
      // Returned under their own name so they can never be read as offers.
      advertisedCarriers: string[]
      warnings: string[]                    // names every dropped source / what the gateway refused
      url: string
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getAutoQuotes

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getAutoQuotes({
      driver: "<driver>",
      vehicle: "<vehicle>",
      state: "<state>",
      zip: "<zip>",
      county: "<county>"
    });
  • getCarrierRatesReturns what a named insurance company charges relative to its competitors.

    Arguments

    NameTypeRequired
    carrierstring
    "GEICO", "State Farm", matched against the site's own 81-carrier roster.
    Yes

    Returns thezebraCarrierRates

    interface thezebraCityIncidentRate {
      incident: string                       // the site's own wording: "DUI", "One comp claim"
      averageSixMonthPremium: number | null
      increase: number | null                // USD over a clean record; null where only a % is printed
    }
    
    // The same fact on both page families, so the same type, an incident row is an
    // incident row whether the page it came from is a state's or a city's.
    type thezebraIncidentRate = thezebraCityIncidentRate
    
    interface thezebraCarrierCompetitorRate {
      carrier: string
      // WHICH group is populated is set by carrierRateBasis, never both.
      liabilitySixMonth: number | null       // splitByCoverage only, USD / 6-month policy
      fullCoverageSixMonth: number | null    // splitByCoverage only
      averageMonthlyPremium: number | null   // blendedMonthly only, a MONTHLY figure
    }
    
    interface thezebraCarrierAgeRate {
      ageBracket: string                     // the site's own wording: "Teens", "20s" … "60s"
      averageMonthlyPremium: number | null   // MONTHLY, as that template publishes it
    }
    
    interface thezebraCarrierRates {
      carrier: string                            // the site's own spelling, e.g. "GEICO"
      asOf: string | null                        // ISO-8601, the review's own dateModified
      // The template-independent pair, from the page's own comparison sentence.
      averageSixMonthPremium: number | null      // THIS carrier's national average
      nationalAverageSixMonthPremium: number | null   // the benchmark it is stated against
      carrierRateBasis: "splitByCoverage" | "blendedMonthly" | null
      byCarrier: thezebraCarrierCompetitorRate[] // includes this carrier; [] is real
      cleanRecordSixMonthPremium: number | null  // the claims table's "None" baseline
      byIncident: thezebraIncidentRate[]         // what THIS carrier charges after a claim
      byAgeBracket: thezebraCarrierAgeRate[]     // [] is real
      warnings: string[]                         // always present; says which axes were unavailable
      url: string
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getCarrierRates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getCarrierRates({ carrier: "GEICO" });
  • getCityRatesReturns car insurance costs for a US city.

    Arguments

    NameTypeRequired
    citystring
    "Austin", "St. Paul", both St./Saint and Ft./Fort spellings resolve.
    Yes
    statestring
    REQUIRED: three states publish a Springfield, so a city alone names no page.
    Yes

    Returns thezebraCityRates

    interface thezebraCityCarrierRate {
      carrier: string
      // WHICH of these three is populated is set by carrierRateBasis, never all three.
      fullCoverageSixMonth: number | null   // splitByCoverage pages only, USD / 6-month policy
      minimumSixMonth: number | null        // splitByCoverage pages only
      averageSixMonth: number | null        // blendedAverage pages only, NOT a full-coverage price
    }
    
    interface thezebraCityIncidentRate {
      incident: string                       // the site's own wording: "DUI", "One comp claim"
      averageSixMonthPremium: number | null
      increase: number | null                // USD over a clean record; null where only a % is printed
    }
    
    interface thezebraCityRates {
      city: string                  // as the page's own <h1> prints it
      state: string
      stateCode: string
      asOf: string | null           // the page's last-updated date; city pages vary by >6 months
      averageSixMonthPremium: number | null
      averageMonthlyPremium: number | null        // only where the page prints it; never divided out
      stateAverageSixMonthPremium: number | null  // this page's own state comparison figure
      carrierRateBasis: "splitByCoverage" | "blendedAverage" | null
      byCarrier: thezebraCityCarrierRate[]        // cheapest first, by whichever figure the basis fills
      cheapestFullCoverage: thezebraCityCarrierRate | null   // null on a blendedAverage page
      cheapestMinimum: thezebraCityCarrierRate | null        // null on a blendedAverage page
      cheapestAverage: thezebraCityCarrierRate | null        // null on a splitByCoverage page
      byIncident: thezebraCityIncidentRate[]      // [] is real: not every page publishes it
      url: string                   // which spelling actually answered
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getCityRates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getCityRates({ city: "Austin", state: "TX" });
  • getRatesByDriverProfileReturns how a driver's own circumstances move their premium.

    Arguments

    NameTypeRequired
    statestring
    Postal code ("CA") or name ("California"); "DC" accepted.
    Yes
    citystring
    OPTIONAL, and the only way to reach the age and credit axes.
    No

    Returns thezebraDriverProfileRates

    interface thezebraCityIncidentRate {
      incident: string                       // the site's own wording: "DUI", "One comp claim"
      averageSixMonthPremium: number | null
      increase: number | null                // USD over a clean record; null where only a % is printed
    }
    
    // The same fact on both page families, so the same type, an incident row is an
    // incident row whether the page it came from is a state's or a city's.
    type thezebraIncidentRate = thezebraCityIncidentRate
    
    interface thezebraCarrierAccidentRate {
      carrier: string
      cleanRecordSixMonth: number | null
      afterAtFaultAccidentSixMonth: number | null
      increaseAfterAtFaultAccident: number | null   // the difference, only where both are published
    }
    
    interface thezebraAgeBracketRate {
      ageBracket: string                     // "Teenagers", "20s" … "70s"
      averageSixMonthPremium: number | null
      cheapestCompanies: string | null       // only where the page names it
    }
    
    interface thezebraCreditTierRate {
      creditTier: string                     // "Very Poor" … "Exceptional"
      averageSixMonthPremium: number | null
    }
    
    interface thezebraDriverProfileRates {
      state: string
      stateCode: string
      city: string | null                    // null when no city was asked for
      asOf: string | null                    // the STATE page's date, not a claim about the city axes
      cleanRecordSixMonthPremium: number | null   // the "None" baseline; null where omitted
      // ALWAYS state-level, including on a city call: the city pages publish a
      // thinner table (3-5 rows vs 21-23) which getCityRates returns as its own
      // byIncident. Same field name, two granularities, on purpose.
      byIncident: thezebraIncidentRate[]
      byCarrierAfterAccident: thezebraCarrierAccidentRate[]
      byAgeBracket: thezebraAgeBracketRate[]      // CITY-ONLY; [] without a city or on a bare template
      byCreditTier: thezebraCreditTierRate[]      // CITY-ONLY, and stricter, see the summary
      warnings: string[]                          // always present; says which axes were unavailable
      urls: string[]                              // every page this answer was read from
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getRatesByDriverProfile

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getRatesByDriverProfile({ state: "TX" });
  • getRentersQuotesReturns REAL renters insurance quotes for one address.

    Arguments

    NameTypeRequired
    address{ street: string; city: string; state: string; zip: string }
    State is a 2-letter code.
    Yes
    applicantthezebraRentersApplicantYes
    livedHereFiveYearsboolean
    The funnel's own question; default true.
    No

    Returns thezebraRentersQuotes

    interface thezebraRentersCoverage {
      name: string           // the site's own label, e.g. "Personal Property"
      value: string          // verbatim, e.g. "$5k", not every row is money ("Covered")
      amount: number | null  // parsed: "$5k" -> 5000, "12 months" -> 12
    }
    
    interface thezebraRentersQuote {
      carrier: string                       // e.g. "Liberty Mutual"
      carrierSlug: string                   // the site's own slug, e.g. "liberty-mutual"
      monthlyPremium: number                // USD per MONTH; the card's period is asserted
      totalPremium: number | null           // USD for the whole term, never derived
      policyLengthMonths: number | null
      deductible: number | null
      personalPropertyLimit: number | null
      personalLiabilityLimit: number | null
      medicalExpensesLimit: number | null
      lossOfUseLimit: number | null
      coverages: thezebraRentersCoverage[]  // every row the card publishes
    }
    
    interface thezebraRentersQuotes {
      quotes: thezebraRentersQuote[]     // cheapest monthly premium first; [] is a real answer
      // The carriers ADVERTISED beside the quotes, paid placements with no price.
      // Returned under their own name so they can never be read as offers.
      advertisedCarriers: string[]
      warnings: string[]
      url: string
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getRentersQuotes

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getRentersQuotes({ address: {}, applicant: "<applicant>" });
  • getStateRatesReturns what car insurance costs in a US state.

    Arguments

    NameTypeRequired
    statestring
    Postal code ("CA") or name ("California"); "DC" accepted.
    Yes

    Returns thezebraStateRates

    interface thezebraCarrierStateRate {
      carrier: string
      liabilitySixMonth: number | null      // minimum coverage, USD per 6-month policy
      fullCoverageSixMonth: number | null   // full coverage, USD per 6-month policy
    }
    
    interface thezebraAnnualAverage {
      year: number
      averagePremium: number | null   // USD per YEAR, as the site printed it
    }
    
    interface thezebraStateRates {
      state: string                 // as The Zebra prints it, e.g. "Washington, D.C."
      stateCode: string
      asOf: string | null           // ISO-8601, the state page's own last-updated date
      averageSixMonthPremium: number | null
      averageMonthlyPremium: number | null
      nationalAverageAnnualByYear: thezebraAnnualAverage[]
      averageAnnualPremiumByYear: thezebraAnnualAverage[]
      byCarrier: thezebraCarrierStateRate[]        // cheapest full coverage first
      cheapestLiability: thezebraCarrierStateRate | null
      cheapestFullCoverage: thezebraCarrierStateRate | null
      indexUrl: string
      carrierRatesUrl: string | null
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getStateRates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getStateRates({ state: "CA" });
  • getStateRequirementsReturns a US state's legally required auto coverage.

    Arguments

    NameTypeRequired
    statestring
    Same jurisdiction set as thezebraStateRatesQuery.
    Yes

    Returns thezebraStateRequirements

    interface thezebraCoverageRequirement {
      coverage: string        // as the site names it, e.g. "Bodily injury per person"
      amount: number | null   // USD. null = not ONE figure (a menu of options), read text
      text: string            // the site's own wording; never null
    }
    
    interface thezebraOptionalCoverage {
      name: string
      description: string
    }
    
    interface thezebraPenalty {
      offense: string | null           // "1st offense" … ; null = page does not break it down
      reinstatementFee: number | null  // USD, only when the page tabulates it as its own column
      text: string                     // the penalty as stated; never null
    }
    
    interface thezebraStateRequirements {
      state: string
      stateCode: string
      asOf: string | null      // ISO-8601, the laws page's own last-updated date
      // The liability triple in WHOLE DOLLARS, never the "30/60/15" string.
      // null = THE STATE DOES NOT REQUIRE IT AT ALL, not zero. Florida requires no
      // bodily-injury liability whatsoever and prints its notation as ", /, /10".
      bodilyInjuryPerPerson: number | null
      bodilyInjuryPerAccident: number | null
      propertyDamage: number | null
      liabilityFormat: string | null   // the site's own notation, verbatim; the audit trail
      noFault: boolean                 // true only when the page says so in its own words
      requiredCoverages: thezebraCoverageRequirement[]   // incl. PIP/PPI a triple cannot express
      optionalCoverages: thezebraOptionalCoverage[]      // where uninsured-motorist is answered
      penalties: thezebraPenalty[]
      url: string
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getStateRequirements

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getStateRequirements({ state: "CA" });
  • getVehicleRatesReturns what it costs to insure a specific vehicle.

    Arguments

    NameTypeRequired
    makestring
    As a person writes it: "Toyota", "Mercedes-Benz", "MINI".
    Yes
    modelstring
    "RAV4", "Model 3", "Prius c".
    Yes
    yearnumber
    Omit for every model year published; a year the site lacks THROWS.
    No

    Returns thezebraVehicleRates

    interface thezebraVehicleCarrierRate {
      carrier: string
      averageAnnualCost: number | null   // USD per YEAR, NOT the 6-month term the rest of this provider returns
    }
    
    interface thezebraVehicleYearRates {
      year: number
      byCarrier: thezebraVehicleCarrierRate[]   // in the site's own cheapest-first order
      cheapest: thezebraVehicleCarrierRate | null
    }
    
    interface thezebraVehicleStateRate {
      state: string
      stateCode: string | null              // null = a row whose state name we do not have a code for
      averageAnnualPremium: number | null   // USD per YEAR, this model in this state
    }
    
    interface thezebraVehicleRates {
      make: string                          // as the page's own <h1> names it
      model: string
      driverProfile: string | null          // the page's own sentence saying WHICH DRIVER these price
      averageMonthlyCost: number | null     // the model's headline figure, USD per MONTH
      vehicleClass: string | null           // the body style compared against: "SUVs", "sedans"
      classAverageMonthlyCost: number | null   // what that class averages, USD per MONTH
      byYear: thezebraVehicleYearRates[]    // newest model year first
      byState: thezebraVehicleStateRate[]   // [] on most models, not an error; read warnings
      warnings: string[]
      url: string
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/thezebra/getVehicleRates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.thezebra.getVehicleRates({ make: "Toyota", model: "RAV4" });

Use it from code