Fuel Prices Scraper: 16 Data Fields, Up to 2,500 Free Results/Month

Each record carries 16 output fields covering national, state, and metro averages for regular, mid-grade, premium, and diesel fuels. Data directly reflects daily published averages from the AAA Fuel Gauge, including historical baselines and derived change metrics in cents. At $2.00 per 1,000 results on Apify's free plan, this tool provides direct pricing benchmarks without requiring proxy setups or session authentication. It is ideal for logistics analysts, news publishers, and economic researchers needing state or metro aggregations. It is not for teams needing station-level or per-pump prices, which are not included.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 2,500 results at $0.002 each before platform usage. Open Fuel Prices Scraper on Apify and run the prefilled example.

How reliable is Fuel Prices Scraper in production?

Across the last 30 days of public runs on the Apify platform, Fuel Prices Scraper recorded 164 runs with the following outcomes.

No run failed or timed out in the last 30 days. Keep a retry and an alert on scheduled runs all the same: a clean month is a record, not a guarantee.

What does it cost to run Fuel Prices Scraper?

Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $20.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The main driver of execution cost is the mode setting combined with the states filter, as these control the total number of dataset items written. A single run in national or state mode returns a bounded set of records, whereas metro mode across all states emits hundreds of items. Setting a specific states allowlist or capping output with maxItems provides the cheapest way to validate output structures before running full regional passes.

How do you run Fuel Prices Scraper from the API?

The schema marks 1 of its 11 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~fuel-prices-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"state"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "state"
}

run = client.actor("crawlerbros~fuel-prices-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "state"
}

const run = await client.actor('crawlerbros~fuel-prices-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Fuel Prices Scraper inputs matter, and which can you skip?

The single required control is mode, which dictates whether the scraper extracts a national summary, state averages, or metro breakdowns. For targeted runs, use states to pass specific two-letter codes, and leave optional filters like minPrice and maxPrice unset on your first run. Most pipelines should stick with the default state mode initially to verify schema structures.

• mode (string): What to scrape. national = single record (US average). state = 51 records (50 states + DC) with current/yesterday/week/month/year-ago prices. metro = metro/county-level prices for the requested states. Default: "state".
• states (array): Two-letter state codes (e.g. NY, CA, TX). Empty = all 50 states + DC. For mode=metro, this controls which state pages get scraped. Default: [].
• fuelTypes (array): Which fuel grades to include in each record. Empty = all four (regular, midGrade, premium, diesel). Default: ["regular","midGrade","premium","diesel"].
• includeHistory (boolean): When true (state/metro modes), include yesterday/week-ago/month-ago/year-ago averages. Default true. Default: true.
• minPrice (number): Drop records whose primary fuel (regular by default) is below this price.
• maxPrice (number): Drop records whose primary fuel (regular by default) is above this price.
• primaryFuelType (string): Which fuel grade is used by minPrice / maxPrice / sortBy filters. Default: regular. Default: "regular".
• sortBy (string): How to order emitted records. Cheapest-first / most-expensive-first / alphabetical by state. Default: "state_asc".
• includeChangeMetrics (boolean): When true and history is fetched, also emit changeFromYesterday, changeFromWeekAgo, changeFromMonthAgo, changeFromYearAgo (in cents). Default: true.
• metroNameFilter (array): Only emit metro records whose name contains one of these substrings (case-insensitive). e.g. ['New York','Los Angeles']. Default: [].
• maxItems (integer): Hard cap on emitted records. Default: 500.

Fixed-choice controls: mode accepts national (National average (1 record)), state (State averages (50 + DC)), metro (Metro/county averages (per-state)); primaryFuelType accepts regular, midGrade (Mid-grade), premium, diesel; sortBy accepts price_asc (Price ascending (cheapest first)), price_desc (Price descending (most expensive first)), state_asc (State alphabetical).

What does Fuel Prices Scraper return?

Returned records are structured for regional fuel pricing analyses, providing clean numerical values for current prices, historical baselines, and period deltas in cents. Empty fields are omitted entirely rather than returned as nulls when specific fuel grades are unpublished. The dataset explicitly omits station-level street addresses, individual gas station names, and real-time per-pump price feeds.

• scope (national / state / metro)
• country (national only - always US)
• state, stateCode (state and metro records)
• metro (metro records only)
• regular, midGrade, premium, diesel (USD/gal - only fuels actually published)
• history (object - yesterday / weekAgo / monthAgo / yearAgo × fuel grade)
• changeFromYesterday, changeFromWeekAgo, changeFromMonthAgo, changeFromYearAgo (cents - computed from primaryFuelType, default regular)
• recordType: "fuelPrices", scrapedAt

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Fuel Prices Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select mode as state or metro depending on whether state aggregates or city-level breakdowns are required.
2. Set the fuelTypes array to restrict output fields strictly to the grades needed, such as diesel for logistics modeling.
3. Specify target two-letter postal abbreviations in states to limit requests to specific geographic areas.
4. Set primaryFuelType to regular or diesel to control minPrice, maxPrice, and sortBy evaluations.
5. Select price_asc or price_desc in sortBy to order output records deterministically before writing to the dataset.
6. Ensure includeHistory and includeChangeMetrics are true to populate past averages and cents-based delta fields.
7. Set maxItems to cap the total emitted dataset items and control per-result charges.
8. Execute the run and inspect dataset items to verify that omitted values drop cleanly without emitting nulls.

How do you apply it? Three worked playbooks

These are Fuel Prices Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Fleet planning

Outcome: Compare diesel prices across states for routing

Configure: {"mode":"state","primaryFuelType":"diesel","fuelTypes":["diesel"],"sortBy":"price_asc"}

Working method: Execute a run with mode set to state and primaryFuelType set to diesel. Inspect the diesel price field across emitted state records to construct cost-ranked transportation corridors.

Deliverable: A state-by-state price matrix containing diesel averages ranked from lowest to highest cost.

Stop condition: Any state record drops the diesel field entirely from the output.

Use case 2: News + editorial

Outcome: Daily "where gas is cheapest" digest, broken out by state and metro

Configure: {"mode":"metro","primaryFuelType":"regular","sortBy":"price_asc","maxItems":100}

Working method: Execute a daily metro run to extract county and metro averages. Filter top records sorted by price_asc to identify the lowest regular gas prices across metro areas.

Deliverable: A structured list of top metro areas with current regular fuel prices and regional state codes.

Stop condition: The metro field is empty or missing across returned regional records.

Use case 3: Trend tracking

Outcome: Monitor changeFromYearAgo to flag big YoY moves

Configure: {"mode":"state","includeHistory":true,"includeChangeMetrics":true,"primaryFuelType":"regular"}

Working method: Run state mode with includeChangeMetrics enabled. Parse the changeFromYearAgo field across all state records to spot significant year-over-year price shifts in cents.

Deliverable: A summary report mapping stateCode to changeFromYearAgo values for economic tracking.

Stop condition: The changeFromYearAgo field is consistently missing due to unpopulated historical data.

What breaks, and how do you design around it?

• Over the last 30 days, 0.0% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

When tracking specific metropolitan areas, use metroNameFilter with exact case-insensitive substrings to prevent fetching unneeded county records. If a state omits a specific fuel grade, design downstream parsers to handle key omission gracefully rather than expecting null values. To avoid unexpected result charges during broad metro runs, explicitly set maxItems to cap dataset size.

When should you not use Fuel Prices Scraper?

Do not use this Actor if your application requires station-specific or per-pump fuel prices, as it only collects national, state, and metro aggregates. If you need hyper-local vehicle data or automotive marketplace pricing, consider multi-site aggregators like AutoTempest Car Listings Scraper or regional classified tools like Bazos.cz / Bazos.sk / Bazos.at / Bazos.pl Scraper. Furthermore, if your research focuses on general US macroeconomic employment trends rather than fuel, use US National Contractor Employment & Wages (BLS).

What should you check before trusting the output?

• Verify that the scope field matches the requested mode string for every emitted record.
• Check that regular, midGrade, premium, or diesel numeric values exist for all targeted fuel grades.
• Ensure changeFromYearAgo is present whenever historical baseline data exists for that location.
• Confirm stateCode contains a valid two-letter uppercase code on state and metro records.
• Halt downstream ingestion if maxItems is reached but expected state records are missing.

None of this proves a record is correct. It gives a scheduled Fuel Prices Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Does this Actor require proxy configurations or browser logins?

No. The scraper operates purely via HTTP requests without requiring proxies, custom cookies, or session authentication.

How much does it cost to run across all 50 states?

A complete state mode run produces 51 dataset results. At $2.00 per 1,000 results on Apify's free plan, the dataset charge is approximately $0.102 per run, plus minimal platform compute usage.

Why are individual gas station prices missing from the dataset?

Station-level data sources heavily rate-limit traffic and block datacenter IP addresses. AAA state and metro aggregate tables offer a consistent, datacenter-friendly source for public fuel price metrics.

How often is the underlying fuel data updated?

AAA updates its Fuel Gauge metrics daily overnight. Each execution fetches live data directly from the published pages to reflect the latest daily averages.

Does the scraper collect fuel price data for countries outside the US?

No. The underlying data source covers only the United States, including state-level records for all 50 states and Washington, D.C.

Where to go next

When you are ready to run it, open Fuel Prices Scraper on Apify; the free plan covers up to 2,500 results a month.

Start with the Fuel Prices Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Product and price scrapers covers 378 Actors in this family.

Other Actors we maintain for related data:

• Bazos.cz / Bazos.sk / Bazos.at / Bazos.pl Scraper: Search the Bazos classifieds marketplace across CZ (bazos.cz), SK (bazos.sk), AT (bazos.at), and PL (bazos.pl) by keyword.
• Great Schools Scraper: Scrape 100,000+ US public schools from the NCES (National Center for Education Statistics) dataset.
• Drive.com.au Car Listings Scraper (Carsales-compatible): Scrape Australian car listings from Drive.com.au.
• US National Contractor Employment & Wages (BLS): Scrape US NATIONAL contractor employment numbers, average wages, and weekly hours by construction trade via the Bureau of Labor Statistics CES program.
• AutoTempest Car Listings Scraper: Scrape aggregated used-car listings from AutoTempest.com - a multi-site search engine spanning Cars.com, Carvana, eBay Motors, TrueCar, AutoByTel, and dealer networks.
• Mobile De Vehicle Scraper: Scrape vehicle listings from mobile.de, Germany's largest online car marketplace.
• Shopify Scraper Pro: Scrape any Shopify store(s) at scale: products, collections, search, on-sale tracking, multi-store batches.
• Spotahome Mid-Term Rentals Scraper: Scrape Spotahome.com - the mid/long-term furnished rental marketplace covering 92 cities across Europe, the UAE and Turkey.

Related guides:

• Boat Trader Scraper: 3 Practical Use Cases
• AutoTempest Car Listings Scraper: 21 Data Fields per Record (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-26.

• Actor last updated by its maintainers on 2026-05-02.

• Run outcome figures cover the 30 day public window ending 2026-09-26.

• Fuel Prices Scraper on Apify