DEV Community: Noraina Nordin

How to Scrape Google Flights

Noraina Nordin — Fri, 14 Aug 2026 10:50:50 +0000

Google Flights is Google's free flight search service, part of the Google Travel platform. It aggregates flights from multiple airlines so travelers can search by departure and destination, compare prices across carriers, track fares, and book tickets in one place.

That aggregated data is exactly what makes Google Flights worth scraping. If you want to build or research flight prices, routes, and availability, scraping Google Flights gives you a rich, continuously updated data source, and SerpApi's Google Flights API lets you pull it as structured JSON in Python, JavaScript, or in any programming language of your choice without maintaining your own scraper.

Google Flights User Interface

Who Needs the Scraped Google Flights Data?

Travel agencies and online travel businesses use it for market analysis and competitive intelligence. They can track competitors' pricing strategies, route popularity, and demand trends. With that visibility, they can adjust their own fares and offers to stay competitive.

Developers use it to build flight comparison platforms, fare trackers, and AI travel assistants. All of these need live prices, routes, and availability. The API supplies that data on demand, so there's no fragile in-house flight scraper to build or maintain.

Available Data on the Google Flights API

Before scraping, it helps to understand the structure of the data returned.

Flight Results

A response is organized into two main arrays:

best_flights : The top options for your search criteria. However, note that these results are not always returned by Google Flights itself.
other_flights : The remaining options, in the same structure.

Each entry contains a list of individual flights with:

Departure and arrival airports and times
Duration, airplane model, airline, travel class, and flight number
Layover details (duration, and whether it's overnight)
The journey's total_duration, carbon emissions data, and price
An extensions array of flight features, and ticket_also_sold_by
A departure_token (used to fetch the return legs of a round trip)

Full field-by-field detail is in the Google Flights API documentation.

Price Insights

Each response also carries a price_insights object, so you can tell whether a fare is a good deal:

lowest_price : The cheapest ticket among the options
price_level : The affordability tier for that price
typical_price_range : A [low, high] array of expected prices for the route
price_history : Timestamped price points, ideal for a price-tracking chart

More detail in the price insights documentation. We'll read these fields in the Scrape flight prices section.

Basic Google Flights Data Scraping

You can get structured Google Flights data with a single GET request using SerpApi's Google Flights API.

Prefer to watch? Here's a quick walkthrough of scraping Google Flights with the API:

https://www.youtube.com/embed/zqZSvuj7JMs?feature=oembed

Setting Up a SerpApi Account

SerpApi offers a free plan for newly created accounts. Head to the sign-up page to register an account and complete your first search with our interactive playground.

When you want to do more searches with us, please visit the pricing page.

Once you are familiar with all the results, you can utilize SERP APIs using yourAPI Key.

SerpApi Google Flights API data from playground

Search by Airport Code

Search a route by IATA airport code (find codes on IATA's site or Google Flights).

Let's find the best flights to Berlin. The data contains: "total_duration", "price", "type", "number_of_flights", and more.

cURL implementation

The simplest way to test the API:

curl --get https://serpapi.com/search \
 -d api_key="SERPAPI_API_KEY" \
 -d engine="google_flights" \
 -d departure_id="AUS" \
 -d arrival_id="BER" \
 -d outbound_date="2026-09-15" \
 -d return_date="2026-09-22"

Python Implementation

First, install the SerpApi client library.

pip install serpapi

Get your API Key fromSerpApi credentials and run a basic search. Store your key as an environment variable (export SERPAPI_KEY=your_key) and read it with os.getenv:

import os
import serpapi

client = serpapi.Client(api_key=os.getenv("SERPAPI_API_KEY"))

params = {
    "engine": "google_flights",
    "departure_id": "AUS",
    "arrival_id": "BER",
    "outbound_date": "2026-09-15",
    "return_date": "2026-09-22",
    "currency": "USD",
    "hl": "en",
}

results = client.search(params)
print(results)

The results object behaves like a regular dictionary, so you can read fields straight off it.

Let's say you only want the price, total duration, type, and number of flights from each of the best options:

for item in results.get("best_flights", []):
    print("Price:", item.get("price"))
    print("Total duration (min):", item.get("total_duration"))
    print("Type:", item.get("type"))
    print("Number of flights:", len(item.get("flights", [])))
    print("-" * 20)

Finally, let's export the data to a CSV file for easier analysis.

import csv

header = ["total_duration", "price", "type", "number_of_flights"]

with open("google_flights.csv", "w", encoding="UTF8", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(header)
    for item in results.get("best_flights", []):
        writer.writerow([
            item.get("total_duration"),
            item.get("price"),
            item.get("type"),
            len(item.get("flights", [])),
        ])

print("Data exported to google_flights.csv")

The result:

Google Flight Result in CSV format

JavaScript Implementation

Install the serpapi package:

npm install serpapi

Run a basic query:

const { getJson } = require("serpapi");

getJson({
    api_key: "SERPAPI_API_KEY",
    engine: "google_flights",
    departure_id: "AUS",
    arrival_id: "BER",
    outbound_date: "2026-09-15",
    return_date: "2026-09-22",
    currency: "USD",
    hl: "en",
}, (results) => {
    console.log(results["best_flights"]);
});

More on the library: serpapi-javascript on GitHub.

You can call the API with a plain GET request in any language. Ready-made libraries for Ruby, PHP, Java, Go, and more are listed on SerpApi Integrations.

Search by city ID

To include every airport in a city, search by city ID instead of an airport code. City IDs can be retrieved with the Google Maps API:

params.update({"departure_id": "/m/04jpl", "arrival_id": "/m/07dfk"})
results = client.search(params)

Customize the Flight Search

The API exposes the same controls you'd use on Google Flights itself. Add any of these to the params dict from the basic search, then run client.search(params) again.

Round-trip vs. one-way

Set type to 1 for a round trip (default), 2 for one-way, or 3 for multi-city. A round trip needs a return_date:

params.update({
    "type": "1",
    "outbound_date": "2026-09-15",
    "return_date": "2026-09-22",
})

Retrieving the returning flights

A round-trip search returns only the outbound flights first. Each outbound flight carries its own departure_token, you need to pass it back to get that flight's return options:

params.update({
    "type": "1",
    "departure_token": "PASTE_DEPARTURE_TOKEN_FROM_PREVIOUS_RESPONSE",
})

(This is the Google Flights equivalent of pagination. You drill into a flight rather than page through a list.)

Scrape flight prices and price insights

Prices are usually the whole point of a flight price scraper. Every response carries the fare on each option plus the price_insights object described in the data structure.

import os
import serpapi

client = serpapi.Client(api_key=os.getenv("SERPAPI_API_KEY"))

results = client.search({
    "engine": "google_flights",
    "departure_id": "JFK",
    "arrival_id": "LHR",
    "outbound_date": "2026-09-15",
    "return_date": "2026-09-22",
    "currency": "USD",
})

insights = results.get("price_insights", {})
print("Lowest price:", insights.get("lowest_price"))
print("Price level:", insights.get("price_level"))            # e.g. "low", "typical", "high"
print("Typical range:", insights.get("typical_price_range"))  # [low, high]

# The cheapest fares from the results themselves
for item in results.get("best_flights", []):
    print(item.get("price"), "-", item.get("total_duration"), "min")

Because the response is already structured, scraping flight pricing is just reading fields without HTML parsing or broken selectors. To watch a route over time, run the same request on a schedule and store lowest_price and price_history on each run.

Cabin class

travel_class: 1 Economy (default), 2 Premium economy, 3 Business, 4 First.

params.update({"travel_class": "3"})   # Business

Filter by airline

exclude_airlines drops carriers while include_airlines keeps only the ones you name (comma-separated). The two can't be combined:

params.update({"exclude_airlines": "MH,EY"})   # or {"include_airlines": "QF"}

Stops, duration, and other filters

Filter by number of stops with stops: 0 any (default), 1 nonstop only, 2 one stop or fewer, 3 two stops or fewer.

params.update({"stops": "1"})   # nonstop only

Add any of these to narrow results further:

max_duration : The total trip-time cap in minutes (e.g. "1400")
layover_duration : Layover range in minutes, two-number string (e.g. "250,300")
exclude_conns : Exclude a connecting airport by ID (e.g. "AUH")
outbound_times / return_times : Departure hour ranges (e.g. "14,18" = 2–6 PM)
max_price : Upper price limit for the whole trip (e.g. "600")
sort_by : 1 Top flights (default), 2 Price, 3 Departure time, 4 Arrival time, 5 Duration, 6 Emissions

For full list check out the advanced filter parameters in the documentation.

Flexible dates

Google Flights has no native flexible-date search, but a few lines turn the API into a flexible-date flight scraper. Loop over a window and collect the cheapest fare per day:

import os
import serpapi
from datetime import date, timedelta

client = serpapi.Client(api_key=os.getenv("SERPAPI_API_KEY"))

def search_flexible_dates(origin, destination, flexible_days):
    start = date(2026, 9, 15)
    for i in range(flexible_days):
        outbound = start + timedelta(days=i)
        return_date = outbound + timedelta(days=7)   # adjust trip length as needed

        results = client.search({
            "engine": "google_flights",
            "departure_id": origin,
            "arrival_id": destination,
            "outbound_date": outbound.isoformat(),
            "return_date": return_date.isoformat(),
            "currency": "USD",
            "hl": "en",
            "type": "1",
        })
        print(f"\nOutbound: {outbound} | Return: {return_date}")
        for item in results.get("best_flights", []):
            for flight in item["flights"]:
                print(
                    f"{flight['flight_number']} | "
                    f"{flight['departure_airport']['id']} -> {flight['arrival_airport']['id']} | "
                    f"{flight['airline']} | {item['total_duration']} min | "
                    f"{item['price']} {results['search_parameters']['currency']}"
                )

search_flexible_dates("JFK", "LAX", 3)

Groups of passengers

Tailor results to a group with adults, children, infants_in_seat, and infants_on_lap:

params.update({
    "adults": "3",
    "children": "2",
    "infants_in_seat": "1",
    "infants_on_lap": "1",
})

Bonus: Deals and airport autocomplete

Hunting for cheap fares specifically? See the Google Flights Deals API and our tutorial: How to Scrape Google Flights Deals.
Building a search box? The Google Flights Autocomplete API returns airport and city suggestions.

Frequently Asked Questions (FAQs)

Is it legal to scrape Google Flights?

Collecting publicly available data is generally permitted, and using an API like SerpApi keeps you off Google's infrastructure. Always review the applicable terms of service for your use case.

How do I scrape flight prices?

Send a Google Flights API request for your route and read the price on each flight plus the price_insights object (lowest_price, price_level, typical_price_range, price_history). See the scrape flight prices section above for a working example.

How do I scrape Google Flights in Python?

Install the serpapi package (pip install serpapi), create a client with your API key, and call client.search() with engine="google_flights" and your route parameters. The results are returned in JSON format, so no HTML scraping is required. The full code is in Basic Google Flights Data Scraping.

How much does it cost?

Why scrape Google Flights data?

Live flight prices, routes, and availability power price-comparison tools, fare trackers, travel dashboards, and market analysis for travel businesses without maintaining a fragile scraper.

Wrapping Up

That's it! You can now scrape Google Flights end-to-end: set up the API, understand the response, run a basic search, and customize it by route, dates, prices, class, filters, and passengers. Experiment for free in the Google Flights playground.

Building a broader travel product? Pair this with our other travel APIs:

If you have any questions, feel free to contact our team at contact@serpapi.com.

How to Scrape Google Maps Autocomplete

Noraina Nordin — Thu, 06 Aug 2026 09:56:15 +0000

Google Maps Autocomplete creates a faster and smoother experience when users search for an address, place, or business location. The same as-you-type suggestions developers know from Google Places Autocomplete. Whether you're building a food delivery app, travel platform, store locator, CRM, or local search tool, the Google Maps Autocomplete helps users find the right location with fewer keystrokes.

Google Maps Autocomplete

What Does Google Maps Autocomplete API Do

The Google Maps Autocomplete API by SerpApi allows developers to retrieve autocomplete suggestions from Google Maps with a simple API request. Because each place suggestion comes back with its street address attached, it doubles as an address autocomplete API for any app where users need to find a place or street quickly.

Instead of managing browser automation or reverse engineering Google's autocomplete responses, you receive structured JSON that can be integrated directly into your application. No key juggling, no CAPTCHAs, no proxy pool. You send a query and a location, and you get back the same suggestions Google Maps would show, ready to drop into a search box, an address form, or a data pipeline.

SerpApi's Google Maps Autocomplete API documentation

In this tutorial, you'll learn how to scrape the autocomplete suggestions from Google Maps using a simple API with cURL, Python, and JavaScript, how to customize requests, and what data you can retrieve.

How Does the Google Maps Autocomplete API Work

The API takes a partial query (q) and a set of GPS coordinates (ll) and returns the list of suggestions Google Maps would show for that input from that location. Some suggestions are plain keyword completions, some are specific places, and those come enriched with an address, latitude and longitude, and a data_id.

That data_id is the part worth paying attention to. It's the same identifier the rest of the Google Maps family uses, so an autocomplete suggestion is an entry point, not a dead end. Pick a place from the suggestions, and you can pass its data_id straight to the Google Maps Reviews API or Google Maps Photos API to pull everything Google knows about it.

Try it out in the playground

What data you can extract

Each suggestion in the response can include:

value: the suggested keyword or place name
type: either keyword (a search completion) or place (a specific location)
subtext: for places, typically the street address
latitude/longitude: coordinates of the place
data_id: the place identifier, reusable across the Maps, Reviews, and Photos APIs
reviews_serpapi_link: a ready-made link to that place's reviews
photos_serpapi_link: a ready-made link to that place's photos
maps_serpapi_link : a ready-made link to that place's full Google Maps listing

How to use the Autocomplete API

Here's the quickest way to see the data before writing any code.

Step 1: Open the playground

Head to the Google Maps Autocomplete playground. No sign-up is needed to run a first search.

Step 2: Enter a query and coordinates

Set q to the partial term a user might type, let's say cafe and set ll to the location the search should originate from, in the format @latitude,longitude,zoom, for example @40.7455096,-74.0083012,14z. The zoom value ranges from 3z (fully zoomed out) to 21z (fully zoomed in). If you need to find coordinates for a place, our guide on how to find the GPS coordinates of any place walks through it.

SerpApi's Google Maps Autocomplete Playground

Step 3: Run the search

The response comes back as JSON, with keyword completions and nearby places interleaved the way Google Maps returns them. A trimmed example for q=cafe:

"suggestions":[
   {
      "value":"cafè",
      "serpapi_link":"https://serpapi.com/search.json?engine=google_maps_autocomplete&ll=%4040.7455096%2C-74.0083012%2C14z&q=caf%C3%A8",
      "maps_serpapi_link":"https://serpapi.com/search.json?engine=google_maps&google_domain=google.com&hl=en&ll=%4040.7455096%2C-74.0083012%2C14z&q=caf%C3%A8&type=search",
      "type":"keyword"
   },
   {
      "value":"Cafe Paradiso",
      "serpapi_link":"https://serpapi.com/search.json?engine=google_maps_autocomplete&ll=%4040.7455096%2C-74.0083012%2C14z&q=Cafe+Paradiso",
      "subtext":"West 65th Street, New York, NY",
      "type":"place",
      "latitude":40.7733834,
      "longitude":-73.9835585,
      "data_id":"0x89c2596625484969:0xdcf19d6c26e407c2",
      "reviews_serpapi_link":"https://serpapi.com/search.json?data_id=0x89c2596625484969%3A0xdcf19d6c26e407c2&engine=google_maps_reviews&hl=en",
      "photos_serpapi_link":"https://serpapi.com/search.json?data_id=0x89c2596625484969%3A0xdcf19d6c26e407c2&engine=google_maps_photos&hl=en",
      "maps_serpapi_link":"https://serpapi.com/search.json?data=%214m5%213m4%211s0x89c2596625484969%3A0xdcf19d6c26e407c2%218m2%213d40.7733834%214d-73.9835585&engine=google_maps&google_domain=google.com&hl=en&ll=%4040.7455096%2C-74.0083012%2C14z&q=Cafe+Paradiso&type=place"
   },

  ...
  ...
  ...

  }
]

cURL

The quickest way to call the API from the command line is a single GET request. Pass your query in q, the origin coordinates in ll, and your API key:

curl --get "https://serpapi.com/search" \
  -d engine="google_maps_autocomplete" \
  -d q="cafe" \
  -d ll="@40.7455096,-74.0083012,14z" \
  -d api_key="YOUR_SERPAPI_API_KEY"

The response is the same structured JSON shown above. From here, the Python and JavaScript examples below wrap the same request so you can parse the suggestions in your app.

Python tutorial

First install the SerpApi client library (GitHub):

pip install serpapi

Then set your API key and run the search:

import serpapi

client = serpapi.Client(api_key="YOUR_SERPAPI_API_KEY")
results = client.search({
    "engine": "google_maps_autocomplete",
    "q": "cafe",
    "ll": "@40.7455096,-74.0083012,14z",
    "gl": "us",
    "hl": "en"
})

print(results)

To get the suggestions and their type:

for suggestion in results.get("suggestions", []):
    print(suggestion["value"], "-", suggestion.get("type"))

To keep only the place suggestions and their data_id:

places = [s for s in results.get("suggestions", []) if s.get("type") == "place"]

for place in places:
    print(place["value"], place.get("subtext"), place.get("data_id"))

The result:

Results from the Python script

JavaScript tutorial

Install the package:

npm install serpapi

The example code:

import { getJson } from "serpapi";

const API_KEY = process.env["API_KEY"]; // https://serpapi.com/manage-api-key

async function getSuggestions(query) {
  const response = await getJson("google_maps_autocomplete", {
    api_key: API_KEY,
    q: query,
    ll: "@40.7455096,-74.0083012,14z",
    gl: "us",
    hl: "en"
  });
  return response["suggestions"];
}

console.log(await getSuggestions("cafe"));

To get the suggestions and their type:

const suggestions = await getSuggestions("cafe");

for (const suggestion of suggestions) {
  console.log(suggestion.value, "-", suggestion.type);
}

To keep only the place suggestions and their data_id:

const places = suggestions.filter((s) => s.type === "place");

for (const place of places) {
  console.log(place.value, place.subtext, place.data_id);
}

Since every place suggestion carries a data_id, you can pass it straight to the Reviews or Photos API to pull that place's reviews or photos, with no separate request to look it up.

Common use cases

Search-as-you-type place pickers. Feed the suggestions straight into an autocomplete dropdown so users can select a business or landmark as they type, with coordinates already attached.
Address and location entry. Speed up checkout, sign-up, and booking forms with location suggestions, without standing up and metering your own Places Autocomplete key.
Seeding data pipelines. Use autocomplete as the first step in a scrape. Resolve a partial name into a concrete data_id, then pull the full place, its reviews, and its photos from the rest of the Maps APIs.
Local keyword and place discovery. Vary the ll coordinates to see which places and completions Google surfaces from different locations, useful for local research and coverage checks.

FAQ

Is the Google Maps Autocomplete API free?

SerpApi's free plan includes 250 searches per month with no credit card required, which is enough to build and test an integration before you commit to a plan.

Do I need to pass coordinates?

Yes. The ll parameter is required, since autocomplete results depend on where the search originates. The gl and hl parameters for country and language are optional.

Can I use it as an address autocomplete API?

Yes. Because each place suggestion comes back with its street address attached, it works as an address autocomplete API for address forms, checkout pages, and any interface where users need address suggestions.

Can I get full place details from a suggestion?

Yes. Each place suggestion includes a data_id you can pass to the Google Maps API, Reviews API, or Photos API to retrieve ratings, hours, reviews, photos, and more.

How is this different from Google Places Autocomplete?

Google Places Autocomplete is Google's own service. The difference is operational: with SerpApi, there's no Google Cloud project, API key, or billing to set up, and no session tokens to manage. Every place suggestion chains directly into SerpApi's other Google Maps endpoints for reviews, photos, and full place details.

Documentation

For a broader look at pulling place data, ratings, and reviews from Google Maps, see our Google Maps Scraper guide. If you're after search keyword suggestions rather than places, our guide on how to scrape Google Autocomplete results covers the Google Search side.

You can reach us at contact@serpapi.com for any questions.

Google Search Parameters (2026 Guide)

Noraina Nordin — Mon, 03 Aug 2026 09:36:47 +0000

The Google Search URL parameters are important to understand whether you are maximizing the conversion rate in your ad groups and optimizing your cost per click(CPC) rates in Google Analytics for your ad campaigns, improving your SEO(Search Engine Optimization) metrics for your e-commerce business, or collecting data for your social media project. Using custom parameters for your search will affect the Search Engine Result Page (SERP) data significantly in your favor. SerpApi unlocks the power of SERP data to you with minimal effort, the fastest response times, and in the most complete form.

Register to claim free credits

In this blog post, we will explore some of the Google search parameters with their corresponding attributions in SerpApi Documentation. You can head to SerpApi Playground to test all of the information you will read below.

What are Google Search parameters?

Google Search parameters are like special codes you can add to the web address (URL) when you search on Google. They help you control and customize your search results. For example, you can use them to specify the language or location for your search.

Here's how they work: When you type a search query into Google, it creates a URL with your search terms. You can then add parameters to this URL using an ampersand (&) followed by the parameter name and value. These parameters, often called "params" for short, tell Google how you want your search results to be customized.

For instance, if you want to search for "cats" in Spanish, you could add "hl=es" to the end of the URL. This tells Google to show results in Spanish. Once you've added all the parameters you want, you have your final URL ready for tailoring your tracking template. When you open this URL in your web browser, Google will show you search results based on the parameters you've specified.

The `q` parameter

It represents the search query submitted to Google. For example, in "q=Coffee", "Coffee" is the query you're searching for. It can also be used with special commands for filtering specific file types, filtering keywords in URLs and bodies, etc. giving you more exact matches. Some of these advanced search operators include filetype, inurl, intitle, intext, inanchor, allinurl, allinanchor, allintitle, allintext. You can check out Ultimate Guide to Google Search Operators for detailed, and up-to-date information on how to use Google search operators.

Google search with q parameter

Reference in SerpApi Documentation

The 'oq' parameter of Google represents the query typed into the Google search box.

Google search with oq parameter

The `hl` parameter

It stands for a ' host language', and it determines the language used for the search. There are different versions of the 'hl' parameter you can pass to a Google Search. The two-letter version is for all languages supported by Google.

For example, "hl=en" searches in English. There are also two-letter versions followed by a hyphen and two-letter or three-digit versions representing dialects. Examples of this kind are "hl=en-gb" representing British English, or "hl=es-419" representing Latin American Spanish.

Google Search with hl parameter

Reference in SerpApi Documentation

The `gl` parameter

It represents ' geolocation', which can be used to personalize search results based on the region. It is a two-letter country code. For example, "gl=us" will serve results for the United States. It's recommended to be used with the 'location' parameter for more consistent country-specific filtering.

Google Search with gl parameter

Reference in SerpApi Documentation

The `lr` parameter

It stands for ' language restriction', it's used to limit your search results to webpages in a specific language or languages. It is a two-letter language code preceded by the word lang and an underscore. Multiple languages can be passed using a bar symbol.

For example "lr=lang_en|lang_fr" will restrict the results to websites with only English and French languages.

Google Search with lr parameter

Reference in SerpApi Documentation

The `cr` parameter

It represents ' country restriction', it refines results based on preferred region. It is a two-letter uppercase country code preceded by the word country. Multiple countries can be passed using a bar symbol.

For example, "cr=countryUS|countryFR" will restrict the results pages to the United States and France.

Google Search with lr parameter

Reference in SerpApi Documentation

The `tbs` parameter

It stands for ' to be searched', it can be used for various purposes (it's optional), for example, to filter results by a specific date or a date range (e.g., past week, past month).

For example, "tbs=qdr:h" will serve only the results from the last hour.

Google Search with tbs parameter

Reference in SerpApi Documentation

The `source` parameter

It indicates the source of your search , such as the Google homepage or a referral from another website.

For example, "source=hp" means that the page was accessed through the homepage.

Google Search with search parameter

The `ei` parameter

It possibly stands for engine identifier , a unique identifier assigned to each search, likely used for internal tracking by Google. Its decoded form consists of four numbers. The first two are a Unix timestamp and microseconds of that timestamp respectively. The last two are undisclosed and unknown.

Google Search with ei parameter

The `ved` parameter

It is used for internal tracking of links and elements. Apart from the link itself, the element index and type can be gathered by decoding the ved value.

Google Search with ved parameter

Open Source Repository for Decoding the ved values

The `gs_lp` parameter

Not much is disclosed about this parameter. It contains the search query and search client.

Google Search with gs_lp parameter

The `iflsig` parameter

This parameter isn't disclosed. It is speculated to be about internal redirects. Other assumptions include relations to parsing.

Google Search with iflsig parameter

The `ibp` parameter

It is responsible for rendering elements differently than their usual format. For example, when used with the ludocid parameter (unique id for a Google Business listing) in a mobile view, "ibp=gwp;0,7&ludocid=1663467585083384531", the 'ibp' parameter can give full page views of the listing.

Google Search with ibp parameter

Reference in SerpApi Documentation

The `kgmid` parameter

The parameter is responsible for serving elements saved by Google including knowledge graph. It can override the 'q' (query) parameter.

For example "kgmid=/m/07gyp7" will get results for McDonald's with a knowledge graph regardless of the query parameter. The parameter is likely acting as a cached version of the Google advanced search parameters.

Google Search with kgmid parameter

Reference in SerpApi Documentation

We write a detailed tutorial on how to find the Google Knowledge Graph ID (kgmid) for anything in the post below:

How to find the Google Knowledge Graph ID (kgmid) for anything

The `si` parameter

It is used to serve knowledge graph tabs alongside other tasks (it's an optional parameter).

For example, in the example below, the 'si' parameter is responsible for serving the Google search results with the 'Music Groups' tab of the knowledge graph for Jimi Hendrix.

Google Search with si parameter

Reference in SerpApi Documentation

💡 For some searches, 'si' may override all other parameters except 'start', and 'num' parameters.

The `sxsrf` parameter

It is possibly an internal token for security. The 'sxsrf' consists of an encoded token probably for security purposes, and a unix timestamp.

Google Search with sxsrf parameter

The `uule` parameter

It is used to specify a location for a search. The 'uule' parameter has two types. The first type is an encoded form of the canonical name of a place in Google Ads API Geo Targets. The second type is an encoded form of the GPS coordinates alongside other data.

Google Search with uule parameter

Reference in SerpApi Documentation

We write more details about the different types of UULE in the post below:

Real World Example of GPS Targeted Local SERP

❗ The 'uule' and location parameters can't be used together.

The `sclient` parameter

It stands for search client. For example "sclient=gws-wiz" means Google Web Search Wizard is used for the search.

Google Search with sclient parameter

The `tbm` parameter

It stands for " to be matched". This parameter is optional and it specifies the type of content that the user is searching for, allowing Google to tailor the search results accordingly.

For instance, "tbm=isch" indicates that the search is intended for image search, while "tbm=nws" directs Google to prioritize results from Google News. By using this parameter, users can fine-tune their searches to precisely start finding pages, sites, or specific content types using Google's sophisticated algorithm.

Additionally, users can specify whether they want to search within meta information, anchor text, or other elements through the appropriate parameters. This level of customization empowers users to efficiently navigate the vast expanse of information accessible through Google's search bar.

Google Search with tbm parameter

Reference in SerpApi Documentation

Use the `safe` parameter to filter explicit results

If your application is designed for general audiences, the safe parameter helps ensure family-friendly results.

Example:

safe=active — filters out explicit content.
safe=off — shows all results without filtering.

This is particularly helpful for educational or public-facing dashboards using SerpApi.

Google Search with safe parameter

Optimize for freshness with the `filter` and `tbs` combo

While tbs=qdr:h limits results to the last hour, pairing it with filter=0 ensures that similar pages are not clustered together—revealing the most recent, diverse results.

Example:

Google Search with filter and tbs combination

This combination is perfect for trend monitoring or social sentiment analysis.

Conclusion

I would like to thank the reader for their attention. I hope this writing could shed some light on how Google search parameters work. For more up-to-date information about web scraping, SERP data, and more related topics, you may visit the SerpApi Blog.

DataForSEO vs. SerpApi

Noraina Nordin — Sun, 02 Aug 2026 09:30:23 +0000

If you're comparing SEO platforms to choose where your search data comes from, whether it's for rank tracking, dashboards, or a Google search ranking API integrated into your product, both DataForSEO and SerpApi are strong options. At a quick glance, they seem similar, but they have important differences.

Live Search Data vs SEO Platform

Despite the overlap on Google SERP data, SerpApi and DataForSEO are built around two different priorities. Which option fits best depends more on your priorities than on any single line item. Price is part of it, and we'll be straight about it further down.

DataForSEO is a broad, pay-as-you-go SEO data platform. Beyond SERPs, it provides backlinks, keywords, on-page, domain analytics, and more, all billed per request from a prepaid balance. Its strongest selling point is low-cost data at scale. It's the raw layer that many SEO dashboards are built on.

SerpApi is a real-time web search API. You make a call, and it returns structured JSON of what a search engine shows for that query. The results include AI overviews, organic results, ads, featured snippets, People Also Ask, the local pack, Shopping, and more than 100 SERP feature types. Its best features are speed, coverage, and developer experience.

DataForSEO is optimized to be the most cost-effective way to store search data. SerpApi is optimized to be the fastest, most complete way to query it in real time. Picking between them is really about which of those two jobs is yours.

SerpApi vs DataForSEO illustration

Data Freshness

The most consequential difference between SerpApi and DataForSEO is how the results reach you.

Search Result Timeline Diagram

DataForSEO's default model is a queue. You submit a task, wait, and retrieve the result later. On the Standard Queue, turnaround is typically around 5 minutes (a Priority Queue cuts it to about 1 minute, and a synchronous Live Mode runs at a higher rate). For batch rank tracking that runs overnight, where five minutes is insignificant, the queue is perfectly suited.

But if your application is customer-facing or agent-driven, where a user types a query and waits, or an LLM that needs search results mid-response, five minutes is a non-starter, and even one minute is. For those workloads, the queue isn't an option. You're choosing between DataForSEO's Live Mode and SerpApi. And "live" doesn't mean equally fast: in our own reproducible benchmark, SerpApi averaged 0.73 seconds per query, compared to 3.57 seconds for DataForSEO's fastest option, and the worst-case gap was wider still, with a p99 of 1.45 seconds versus 13.31 seconds. DataForSEO's own comparison points in the same direction, measuring its live mode at around 6 seconds. For an AI agent making several search calls in a single chain, that difference compounds quickly.

SerpApi is synchronous by default. Every call returns live results in roughly a second, and with Ludicrous Speed / Ludicrous Speed Max you can push median response times well below that. We benchmarked response times across providers in who has the fastest Google Search API. There’s no queue to manage, no task-polling loop to construct. The optional Search Archive API is available if you want to re-fetch past searches; it's for convenience, not a required step. For real-time workloads, fast processing determines whether you can deliver the feature or not.

Do you actually need real-time data?

It's worth meeting the strongest version of the other side head-on because DataForSEO-leaning comparisons have highlighted that most SEO work is batch-based, so you're paying a premium for speed you'll never use. For pure scheduled SEO, such as overnight rank tracking or weekly content-gap reports, that's fair. If nothing is waiting on the result, the queue is the right call.

The argument breaks down on two points. First, the number of applications requiring real-time results is growing rapidly. Gartner estimates that 40% of enterprise applications will have task-specific AI agents integrated by the end of 2026, up from under 5% in 2025. Agents, RAG pipelines, in-product search, and live AI-Overview / GEO monitoring all need a result in a single request. The moment a human or an agent is waiting, the comparison becomes Live Mode at ~ $2.00/1K versus SerpApi. That's a much smaller gap than the headline numbers suggest, and part of it buys back real engineering time. With a synchronous API, there's no poll-and-retrieve layer to build, debug, and maintain.

Second, when DataForSEO-leaning comparisons concede that the queue can't serve real-time use cases, the workaround they tend to suggest is to pair it with Google's Custom Search JSON API for live queries. That pairing doesn't hold up. The Custom Search API is capped at low daily volume, returns a restricted custom-search index rather than the live public SERP, and omits most SERP features and verticals. Offering it as the real-time answer mostly confirms that it's the queue being defended, not your latency needs being met.

The real question is simpler than "batch or real-time": does anything wait on the result? If so, compare SerpApi against Live Mode, and count the poll-and-retrieve layer you won't have to build.

Let's take a look at two scenarios that show how this plays out.

For the SaaS team, the queue is fine for weekly rank reports that can be processed in batches. But AI Overview citations aren't. They appear, vanish, and swap sources far faster than bluelinks move, and being cited for the "best <your category> software" is the new position #1. Monitoring on day-old snapshots means learning you lost the citation days after a competitor's page replaced yours. Checking live means alerting the content team while the cause is still identifiable and answerable.

For an e-commerce team , the gap is larger because automation acts directly on the data. Google Shopping positions are reshuffled in response to competitor price changes, sometimes hourly. So a repricing engine or Minimum Advertised Price (MAP) violation monitor running on 5-minute-old queue data can act on prices that no longer exist. A human reading a stale report adds judgment before acting. An automated repricer doesn't get that chance.

DataForSEO pricing vs. SerpApi pricing

If you're sizing up SerpApi as a DataForSEO alternative, the prices only make sense once you know which speed tier you'd actually use.

DataForSEO is pure pay-as-you-go. No monthly subscription. You prepay a balance (a $50 minimum deposit, with a $1 free trial credit to test first) and draw it down per request. For the SERP API, the same query costs a different amount depending on how fast you need it:

DataForSEO SERP API tier	Price per 1,000 SERPs	Delivery
Standard Queue	~ $0.60	Queued, ~ 5 min turnaround
Priority Queue	~ $1.20	Queued, ~ 1 min turnaround
Live Mode	~ $2.00	Real-time, synchronous

(Base price covers the first 10 results. Since Google removed its num=100 parameter in late 2025, deeper result pages are billed per additional page budget for that if you paginate.)

SerpApi is subscription-based , priced on a monthly bucket of successful searches:

SerpApi Plan	Price	Searches/Month	Price per 1,000 Searches
Free	$0	250	-
Starter	$25	1,000	$25.00
Developer	$75	5,000	$15.00
Production	$150	15,000	$10.00
Big Data	$275	30,000	~ $9.17

Plans scale up to 1,000,000+ searches/month, and an Enterprise tier offers reserved and on-demand pricing for high volume. Only fully successful searches count. While cached, errored, blocked, and CAPTCHA requests are free, unused searches don't roll over.

Look at those two tables side by side, and the takeaway is simple: at the same volume, DataForSEO's price is lower, and it is the better fit for latency-tolerant batch work. SerpApi is the premium option. That's what you get for the real-time speed, one-call integration, wider search-surface coverage, human support, and legal cover , which is what the rest of this comparison walks through.

Ease of Integration

This one rarely makes the spec sheet but shows up on day one of building.

SerpApi

With one API key, you get synchronous request and structured JSON back. Plus, official libraries are available for Python, Ruby, JavaScript, Go, PHP, Java, .NET, Rust, and more, plus an MCP integration for AI assistants.

For quick testing, the playground lets you run a search query with zero code, and one thing I really like about it is that it shows a visual preview of the SERP on the same page you'd see in a regular browser, side by side with the JSON response. When I'm tracing where a field comes from ("which box on the page is this organic_results object?"), I can see the element and its parsed data side by side. DataForSEO's output is JSON only, so mapping a field back to what actually appeared on the page requires opening a browser and reconstructing the SERP yourself. It sounds small. But it stops being small the first time you debug why a value isn't where you expected it to be.

SerpApi Google Search Playground

DataForSEO

The authentication uses a login-plus-API-password credential pair, and the queued endpoints follow a task-based pattern. You POST a task, then either poll for results or wait for a callback to retrieve them. It's well-documented and fine once built, but it really involves more work than a single synchronous GET. (DataForSEO also ships an MCP server, so for AI-assistant workflows, both options exist.)

For solo developers or small teams trying to ship faster, integration friction creates real costs, even if it doesn't appear on the invoice.

Coverage

"Which one covers more?" depends on more of what.

On SERP engines and Google verticals, SerpApi is wider. DataForSEO's SERP API spans roughly 8 engines (Google, Bing, Yahoo, Baidu, Yandex, Naver, Seznam, YouTube). SerpApi supports 100+ APIs across Google Search, Maps, Shopping, Scholar, Trends, Flights, Hotels, Lens, Jobs, News, Patents, and more, as well as Bing, Baidu, Yandex, Naver, DuckDuckGo, Amazon, eBay, Walmart, YouTube, Yelp, Tripadvisor, and others. If your roadmap touches multiple search surfaces, that range matters.

In terms of SEO data types, DataForSEO offers a broader range. Backlinks, a historical keyword database, on-page audits, domain analytics, and its API list go well beyond SERPs. SerpApi doesn't support these features because its main focus is on the web search API rather than an SEO data suite. If you need backlink graphs or a keyword-volume database alongside SERPs, DataForSEO consolidates that in one account.

In short, SerpApi provides the depth and freshness of live search results parsing across many search engines, while DataForSEO provides a wider range of raw SEO datasets in one place.

SerpApi Endpoints That Affect SEO Decisions

Several endpoints return the exact signals that SEO teams call on. A few worth knowing, covered by both SerpApi and DataForSEO:

Pixel Position: the real-browser X/Y coordinates of each result. Nominal "rank #1" can sit well below the fold once ads, an AI Overview, and a featured snippet stack above it. Pixel Position reports actual above-the-fold visibility, per device, so you can tell which rankings are worth defending and which are wins only on paper.
Google AI Overview and AI Mode: whether your content is cited in Google's AI answers, and which domains are. This is the core AEO/GEO decision of 2026: track AI visibility the way you track bluelink rank. We've written about what AI Overviews change for rank tracking in depth.
Rank Tracking in the Age of AI Overviews: What’s Changed
Related Questions (People Also Ask): the questions Google attaches to a query, which map straight to content gaps, FAQ blocks, and subheadings worth writing.
Autocomplete: the long-tail variations real users actually type, for keyword discovery grounded in live suggestions rather than a static database.
Google Trends: demand direction and seasonality, so you prioritize topics that are rising rather than fading.
Google Local: local-pack results by location, for tracking visibility, where the map results, not the organic ones, win the click.

Some endpoints currently lack DataForSEO equivalents, such as the Google Forums API (covering the "Discussions and forums" SERP block where Reddit visibility appears), Google Short Videos, and Bing's vertical results beyond organic Copilot, Images, Maps, News, and Shopping, where DataForSEO only covers organic Bing results.

The key difference is that SerpApi returns the results in a single, real-time call, parsing them in a structured JSON format. This introduces the same real-time versus queued trade-off mentioned earlier, but specifically applied to the signals that inform SEO decisions.

Feature Comparison

Here's the full picture in one place with everything we covered so far, plus a few dimensions that haven't come up yet:

Dimension	SerpApi	DataForSEO
Core model	Real-time search API (subscription)	SEO data platform (pay-as-you-go)
Default delivery	Synchronous, ~1 sec	Queued (Standard/Priority); Live mode synchronous
Pricing	From $25/mo (1K searches); free tier 250/mo	From $0.60/1K (queued) to ~$2.00/1K (live); $50 min deposit
SERP engines	100+ APIs incl. many Google verticals	~8 SERP engines
Other SEO data	SERP-focused (no backlinks/keyword DB)	Backlinks, keyword DB, on-page, domain analytics
SERP feature parsing	100+ feature types as structured objects	Rich features via "Advanced" result type
Integration	Single API key, sync request	Login + API password, task-based queue workflow
Legal	U.S. Legal Shield assumes scraping liability for you	No Legal Shield
Transparency	Public status page + public roadmap	Status page; private roadmap
Best fit	Real-time apps, AI agents, multi-engine SEO tools	High-volume batch data, cost-sensitive pipelines, full SEO suites

Main differentiators

Legal posture. These aren't the same promise. DataForSEO states that scraping publicly available SERP data isn't a CFAA/DMCA violation. i.e., we believe this is legal. SerpApi's U.S. Legal Shield goes further: on recurring paid plans, SerpApi contractually assumes liability for scraping and parsing on your behalf (short of genuinely illegal use). If legal risk transfer is something your company needs in writing, that's a SerpApi-specific feature, not a line item in the price.

Transparency. SerpApi publishes a public status page with 30-day average response times filterable by engine, and a public roadmap where anyone can see bugs and file feature requests consistent with the company's "painful honesty" value. For the infrastructure you're betting a product on, being able to inspect reliability before you commit is worth weighing.

When to choose each

Choose DataForSEO when:

Unit cost is your binding constraint, and you're operating at high volume.
Your workload is batch and latency-tolerant, such as overnight rank tracking and bulk SERP snapshots.
Your usage is spiky, and you'd rather pay only for what you consume than fit into a monthly bucket.
You need backlinks, a keywords database, or on-page data in the same account as your SERPs.

Choose SerpApi when:

Your app is customer-facing, or agent-driven, and results need to be real-time.
You want the simplest possible integration: one key, one synchronous call.
You need a broad engine and Google-vertical coverage with high-fidelity SERP-feature parsing.
Legal liability transfer, public transparency, and responsive support are part of the decision.
You'd rather not build and maintain a task-queue retrieval layer.

FAQ

Is DataForSEO actually cheaper than SerpApi?

On headline per-query price, yes, especially on the Standard Queue (~$0.60/1K vs. SerpApi's $25/1K entry rate). The gap narrows when you need real-time results, since you'd use DataForSEO's Live Mode (~$2.00/1K). And it narrows further once you price in integration time, latency requirements, and whether you need legal cover. Cheapest-per-query isn't the same as cheapest-for-your-project.

Can DataForSEO do real-time?

Yes, via Live Mode, which is synchronous but priced higher than its queued tiers. SerpApi is real-time by default across all plans.

Which has more search engines?

SerpApi, by a wide margin on SERP such as Google, Bing, DuckDuckGo, Baidu, Yandex, Naver, Yahoo, YouTube, Yelp, Tripadvisor, Amazon, eBay, Walmart and more (100+ APIs). DataForSEO covers more SEO data types (backlinks, keyword DB, on-page) but fewer SERP engines.

Can I use both?

Plenty of teams do. DataForSEO for cheap, high-volume batch collection, SerpApi for the real-time and multi-engine paths. They're not mutually exclusive.

Which is the best SERP tracking tool, SerpApi or DataForSEO?

Neither is a turnkey rank tracker. Both are API layers you'd build a SERP-tracking tool on top of. For tracking that runs on a schedule, DataForSEO's queue is cost-efficient, but for tracking that updates on demand or inside a user-facing dashboard, SerpApi's real-time responses are the better fit. Pick the data layer that matches how your tool refreshes.

Is SerpApi a good DataForSEO alternative?

If your use case is real-time or spans multiple search engines, yes — SerpApi covers the SERP side with lower latency and simpler integration. But if you also rely on backlinks, a keyword database, or on-page audits, SerpApi won't replace those parts of DataForSEO. In that case, the answer to "what's the best DataForSEO alternative" is often SerpApi plus a dedicated tool for the rest, rather than a single swap.

Related comparisons

Weighing SerpApi against other providers? We've broken down the trade-offs in each of these:

SerpApi vs. Brave Search API
SerpApi vs. Exa AI
SerpApi vs. Firecrawl: search intelligence vs. website content
SerpApi vs. Serper vs. ValueSERP vs. SearchApi
Who has the fastest Google Search API?

The bottom line

DataForSEO and SerpApi appear to be competitors because both provide Google SERP data. But you're choosing between a pay-as-you-go data warehouse and a real-time search API, and the right answer falls out of one question: is your bottleneck unit cost, or latency, coverage, integration speed, or legal cover?

If you're warehousing search data at scale on a tight budget and can tolerate a queue, DataForSEO's prices are definitely lower. If you're building something where results need to arrive now, such as an AI agent, a customer-facing product, a multi-engine SEO tool, and you'd rather ship than build retrieval plumbing, that's exactly what SerpApi is for.

The good news: you don't have to take anyone's word for the trade-offs. SerpApi's status page and roadmap are public, and the free plan includes 250 searches per month to test real responses against your own queries.

Try a query in the playground and compare the JSON for yourself! If you have questions, reach us at contact@serpapi.com.

Scrape Amazon Product Data (complete 2026 tutorial)

Noraina Nordin — Mon, 27 Jul 2026 19:19:57 +0000

Want to grab Amazon product details—prices, ASINs, reviews, and more—by scraping them into your project? You're in the right place!

In this tutorial, we'll help you learn how to scrape products from Amazon, starting from the very beginning. We’ll show you how to do it yourself or use our Amazon Search API for simplicity.

Feel free to skip to the "API" version, for scalable and easier solution.

DIY Version: Step-by-Step Amazon Web Scraper

Important Note : This method is ideal for those who want to scrape data in small quantities only. Scraping Amazon data is subject to limitations, as Amazon actively attempts to block scraping bots. Therefore, the methods presented here should be used responsibly and within the boundaries of Amazon's terms of service. For production, you can utilize our Amazon Search API, which we also share in this post.

Prerequisites

Before we dive in, make sure you have the following:

Basic Python knowledge (variables, functions, loops).
Python installed (version 3.7+ recommended).
Postman (recommended)
A few Python libraries: requests, beautifulSoup and pandas for saving data.

You can install the necessary libraries with:

pip install requests beautifulsoup4 pandas

Check out our Web Scraping in Python tutorial to learn the basics of web scraping.

Web Scraping in Python (Complete Tutorial 2025)

Step 1: Understanding the Target Page

Let's go to "https://www.amazon.com" and press F12 Or right-click and click on "Inspect" to open DevTools. In the devTools, click on the "Network" tab.

"Network" tabs

After that, make a search in the search bar, for example, "coffee". You'll notice the network logs start changing and a file with the "document" type appears.

"Network" logs after search

Click on that and examine the response tab.

Let's look for a-section a-spacing-base desktop-grid-content-view by using ctrl or cmd + f

Response from the logs

Why need to look for `a-section a-spacing-base desktop-grid-content-view`?

Let's go back to the "Elements" tab and click on this arrow icon

Element inspector

It allows us to hover over the products and identify the HTML tags used.

product elements

Now that we are able to identify that this endpoint will give us the same results as the homepage. Let's make the requests.

Step 2: Making the First Requests

Let's go back to the "Network" tabs and copy the log as cURL

Choose "Copy as cURL"

Open Postman and paste this value. We will get the same response as previously. You can take some time here to explore the "Params" and "Headers" on Postman.

Now, let's click on the </> icon in Postman. This will generate a code sample for us on how to send requests in Python and other languages as well. It will generate something like this:

import requests

url = "https://www.amazon.com/s/ref=nb_sb_noss_1?url=search-alias%3Daps&field-keywords=coffee&crid=BSU3QALDN848&sprefix=coffee%2Caps%2C404"

payload = {}
headers = {
    # This value is intentionally left blank. Make sure to fill it in with actual headers from Postman to mimic a real browser request.
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)

Let's copy and paste the code into our code editor.

Step 3: Parsing the HTML

To parse the HTML, we'll use BeautifulSoup. First, we need to identify the relevant HTML tags or elements. Let's go back to the browser and hover over the product. Let's try to get the "Product Name", "Stars Rating", "Number of Ratings", and "Price"

Information that we want to scrape

Firstly, we need to identify the element for product containers

product container

soup = BeautifulSoup(response.text, 'html.parser')

# Find all product containers
product_containers = soup.find_all('div', {'data-component-type': 's-search-result'})

print(f"Found {len(product_containers)} product containers")

Number of product containers found in the page

Now, let's focus on the first product first

container = product_containers[0]

Scrape "Product Name"

product name is available in h2 tag

product_name = container.find('h2').get_text(strip=True)
print("Product Name:", product_name)

Product Name result

Scrape "Star Ratings" and "Number of Ratings"

Both of these values are inside the same review block.

Rating elements

review_block = container.find('div', {'data-cy': 'reviews-block'})

star_rating = review_block.find('span', {'class': 'a-size-small'}).get_text(strip=True)
number_of_reviews = review_block.find('div', {'data-csa-c-content-id': 'alf-customer-ratings-count-component'}).find('a').get('aria-label')

print("Star Rating:", star_rating, "stars")
print("Number of Ratings:", number_of_reviews)

Star Rating and Number of Ratings result

Scrape "Price"

Price Element

price = container.find('span', {'class': 'a-offscreen'}).get_text(strip=True)
print("Price: $", price)

Price result

Step 4: Loops through all the elements and saves the Data

To save all the products from the first page, we can loop through the product_containers and use pandas to convert the data into a structured CSV file.

def extract_all_products():
    products = []

    for container in product_containers:
        product = {}

        # Extract Product Name
        name_element = container.find('h2')
        if name_element:
            product['product_name'] = name_element.get_text(strip=True)
        else:
            product['product_name'] = 'N/A'

        # Extract Stars Rating and Number of Reviews
        review_block = container.find('div', {'data-cy': 'reviews-block'})
        if review_block:
            # Extract star rating
            star_rating_element = review_block.find('span', {'class': 'a-size-small'})
            if star_rating_element:
                rating_text = star_rating_element.get_text(strip=True)
                rating_match = re.search(r'(\d+\.?\d*)', rating_text)
                product['star_rating'] = rating_match.group(1) if rating_match else 'N/A'
            else:
                product['star_rating'] = 'N/A'

            # Extract number of reviews
            reviews_element = review_block.find('div', {'data-csa-c-content-id': 'alf-customer-ratings-count-component'})
            if reviews_element:
                reviews_link = reviews_element.find('a')
                if reviews_link:
                    reviews_text = reviews_link.get('aria-label', '')
                    reviews_match = re.search(r'([\d,]+)', reviews_text)
                    product['num_rating'] = reviews_match.group(1) if reviews_match else 'N/A'
                else:
                    product['num_rating'] = 'N/A'
            else:
                product['num_rating'] = 'N/A'
        else:
            product['star_rating'] = 'N/A'
            product['num_rating'] = 'N/A'

        # Extract Price
        price_element = container.find('span', {'class': 'a-offscreen'})
        if price_element:
            price_text = price_element.get_text(strip=True)
            # Clean up the price text (remove extra $ symbols)
            price_clean = price_text.replace('$', '').strip()
            product['price'] = price_clean if price_clean else 'N/A'
        else:
            product['price'] = 'N/A'

        # Only add products that have at least a name
        if product['product_name'] != 'N/A':
            products.append(product)

    return products

def save_to_csv(products, filename='amazon_products.csv'):
    """Save products data to CSV file"""
    if not products:
        print("No products to save!")
        return

    # Define CSV fieldnames
    fieldnames = ['product_name', 'star_rating', 'num_rating', 'price']

    with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(products)

    print(f"Data saved to {filename}")

# Extract all products
all_products = extract_all_products()

# Save to CSV
save_to_csv(all_products)

# Display results
print(f"Found {len(all_products)} products:")
print("=" * 80)
for i, product in enumerate(all_products, 1):
    print(f"{i}. {product['product_name']}")
    print(f" Star Rating: {product['star_rating']} stars")
    print(f" Number of Ratings: {product['num_rating']}")
    print(f" Price: ${product['price']}")
    print("-" * 80)

Some Final Results printed in terminal

And you can also find the CSV file in your directory. All the source code is available in this github repo.

Next Steps

You can try scraping the other parameters using the same steps we showed. However, keep in mind that Amazon actively blocks scraping bots. So, methods that work today may not work tomorrow. Also, we only scrape part of the data, but using our Amazon Search API gives a more complete data set.

API: Amazon Search API (Recommended)

You can scrape this data with a straightforward GET request using our new Amazon Search Engine Results API.

We'll show you how to scrape both the search results and the individual product pages.

Amazon Search Engine Results API - SerpApi

Available data on the Amazon Search API

Here is the list of data you can retrieve from this Amazon Search API:

product ads (when available)
organic results
video results
related searches
sponsored brands

Amazon Search API data response visual

The organic_results will include information like:

position
ASIN (Amazon Standard Identification Number)
badges
title
link
thumbnail
rating
reviews
price
offers
and more!

This is perfect if you need to collect product data from Amazon. It's also useful if you're looking to monitor your competitor's products at an online store like Amazon.

How to scrape Amazon Search results?

Now, let's see how to use this simple API from SerpApi to collect the data!

scraping Amazon product data thumbnail

Get your API Key

First, ensure to register at serpapi.com to get your API Key. You can get 100 free searches per month. You can use this API Key to access all of our APIs, including the Amazon Search API.

Available parameters

On top of running the basic search, you can see all of our available parameters here.

Video Tutorial

We also have a video tutorial on scraping Amazon on YouTube:

https://www.youtube.com/embed/j3YXfsMPKjQ?feature=oembed

cURL Implementation

Here is the basic implementation in cURL:

curl --get https://serpapi.com/search \
 -d api_key="YOUR_API_KEY" \
 -d engine="amazon" \
 -d k="Coffee"

The k parameter is responsible for the search query.

Sample response on Terminal

Python Implementation

Next, let's see how to scrape the Amazon search results in Python.

Preparation for accessing the SerpApi API in Python

Create a new main.py file
Install requests with:

pip install requests

Here is what the basic setup looks like:

import requests
SERPAPI_API_KEY = "YOUR_REAL_SERPAPI_API_KEY"

params = {
    "api_key": SERPAPI_API_KEY, #replace with your real API Key
    # soon
}

search = requests.get("https://serpapi.com/search", params=params)
response = search.json()
print(response)

With these few lines of code, we can access all of the search engines available at SerpApi, including the Amazon Search API.

import requests
SERPAPI_API_KEY = "YOUR_SERPAPI_API_KEY"

params = {
    "api_key": SERPAPI_API_KEY, 
    "engine": "amazon",
    "k": "Coffee"
}

search = requests.get("https://serpapi.com/search", params=params)
response = search.json()
print(response)

To make it easier to see the response, let's add indentation.

import json

# ...
# ...
# all previous code

print(json.dumps(response, indent=2))

Print specific information

Let's say we only need the title, ASIN, thumbnail, price, rating, reviews, and link; This is how we can print specific columns from the organic results:

# ...
search = requests.get("https://serpapi.com/search", params=params)
response = search.json()

for result in response.get("organic_results", []):
    title = result.get("title")
    asin = result.get("asin")
    thumbnail = result.get("thumbnail")
    price = result.get("price")
    rating = result.get("rating")
    reviews = result.get("reviews")
    link = result.get("link")

    print(f"Title: {title}")
    print(f"ASIN: {asin}")
    print(f"Thumbnail: {thumbnail}")
    print(f"Price: {price}")
    print(f"Rating: {rating}")
    print(f"Reviews: {reviews}")
    print(f"Link: {link}")
    print("-" * 10)

Scrape Amazon Product ASINs

ASIN stands for Amazon Standard Identification Number, a 10-character alphanumeric code that Amazon uses to identify products. You can collect these ASIN numbers by looping through the search results.

Also Read: How to fetch product details from the ASIN.

Scrape Amazon Product prices

Same with the ASIN number, you can also loop through the search results to collect prices information from each of the items.

Export data to a CSV file

Let's see how to export this Amazon product data into a CSV file in Python

import csv

with open("amazon_results.csv", "w", newline="", encoding="utf-8") as csvfile:
    fieldnames = ["title", "asin", "thumbnail", "price", "rating", "reviews", "link"]
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

    writer.writeheader()
    for result in response.get("organic_results", []):
        writer.writerow({
            "title": result.get("title"),
            "asin": result.get("asin"),
            "thumbnail": result.get("thumbnail"),
            "price": result.get("price"),
            "rating": result.get("rating"),
            "reviews": result.get("reviews"),
            "link": result.get("link")
        })
print("Data exported to amazon_results.csv successfully.")

Export Amazon product data into a CSV file

JavaScript implementation

Finally, let's see how to scrape the Amazon search results in JavaScript.

Install the serpapi package:

npm install serpapi

Run a basic query:

const { getJson } = require("serpapi");
getJson({
  engine: "amazon",
  api_key: API_KEY, // Put your API Key
  k: "coffee"
}, (json) => {
  console.log(json["organic_results"]);
});

More information on our JavaScript library: GitHub - SerpApi-javascript

Other programming languages

While you can use our APIs using a simple GET request with any programming language, you can also see our ready-to-use libraries here: SerpApi Integrations.

How to customize the search?

We provide many filters to customize or filter your programmatic search.

Localize the results:

You can localize the results by adjusting the amazon_domain and language parameter.

amazon_domain: Parameter defines the Amazon domain to use. It defaults to amazon.com. Head to Amazon domains for a full list of supported Amazon domains.
language: Parameter defines the language to use for the Amazon search. It's a locale name represented as <language>_<REGION>. (e.g., on amazon.com en_US for English, es_US for Spanish, or on amazon.co.jp ja_JP for Japanese). Head to the following page for a complete list of supported Amazon languages.

Example using a different Amazon domain:

curl --get https://serpapi.com/search \
 -d api_key="YOUR_API_KEY" \
 -d engine="amazon" \
 -d k="Coffee" \
 -d amazon_domain="amazon.fr"

As you can see, the results are now returned from Amazon French:

Amazon search on different domain

Advanced Parameters:

delivery_zip: ZIP Postal code. To filter the shipping products by a selected area.
shipping_location: Shipping country. To filter the shipping products by a selected country.
s: Parameter is used to sort results. Available options:

relevanceblender - Featured (default)

price-asc-rank - Price: Low to High

price-desc-rank - Price: High to Low

review-rank - Avg. Customer Review

date-desc-rank - Newest Arrivals

exact-aware-popularity-rank - Best Sellers

You can see more of the available parameters on this documentation page.

How to paginate the results?

You can scrape beyond the first page using the page parameter. The default value is 1 for the page result. You can then increase it by one for the next pages.

2 for the 2nd page of results, 3 for the 3rd page of results, etc..

How to scrape Amazon Product Data?

We've seen how to scrape the search results. Next, let's see how to scrape the individual page, simulating when you click one of the products using our Amazon Product API.

Amazon Product API

Video Tutorial

https://www.youtube.com/embed/Yd17Jr45liw?feature=oembed

Python example

Here is the parameter we need to use:

import requests
SERPAPI_API_KEY = "YOUR_SERPAPI_API_KEY"

params = {
  "engine": "amazon_product",
  "asin": "B072MQ5BRX",
  "api_key": "API_KEY"
}

search = requests.get("https://serpapi.com/search", params=params)
response = search.json()
print(response)

engine: The engine needs to be amazon_product
asin: Use ASIN of the product you interested in.

Available Product Information

We return:

Basic product information
Variants
Thumbnail links
Item specifications
Frequently bought together items
Related products (complete with their ASIN numbers)
Sponsored brands
Reviews information

Scrape reviews from an Amazon Product

Let's see how to collect public reviews from a product

import requests
SERPAPI_API_KEY = "YOUR_SERPAPI_API_KEY"

params = {
  "engine": "amazon_product",
  "asin": "B072MQ5BRX",
  "api_key": "API_KEY"
}

search = requests.get("https://serpapi.com/search", params=params)
response = search.json()
print(response["reviews_information"]["authors_reviews"])

Or, if you want to get a specific item from the reviews, let's say title, text, date, and rating:

for review in response["reviews_information"]["authors_reviews"]:
    print("Title:", review["title"])
    print("Text:", review["text"])
    print("Date:", review["date"])
    print("Rating:", review["rating"])
    print("==========================\n")

Result example:

Amazon Product Reviews example

Frequently Asked Questions (FAQs)

Is it legal to scrape the Amazon website?

Scraping publicly available data from websites like Amazon is generally permitted under U.S. law.

How much does it cost?

Register at serpapi.com to start for free. If you want to scale, we offer tiered plans based on your usage.

Why do you need to scrape Amazon product data?

Scraping Amazon product data can provide valuable insights for businesses and individuals looking to enhance their competitive edge and inform decision-making. It allows for effective price monitoring, enabling companies to track price changes over time, adjust their pricing strategies, and implement dynamic pricing to stay competitive in the marketplace.

Additionally, it facilitates comprehensive market research by gathering data on competitor products, reviews, ratings, and sales ranks, which helps understand market trends and customer preferences. Scraping data can also improve inventory management by monitoring stock levels and availability. For consumers and businesses alike, it aids in product comparison, keyword research for visibility optimization, and review analysis to identify common issues and customer sentiment.

Moreover, it can assist in estimating sales volume and generating leads for potential products to promote.

Closing

That's it! Thank you very much for reading this blog post. You can play around for free on our playground here.

If you need other resources to collect more data on a product or monitor prices, please check our other awesome APIs:

How to Scrape Google Shopping Results and Details Product Data

Noraina Nordin — Sun, 26 Jul 2026 19:14:52 +0000

Does Google have its own e-commerce platform? Not exactly.

Google Shopping is a product discovery and comparison service provided by Google. It allows users to search for products, compare prices, and view offers from multiple online retailers, but the actual purchase happens on the retailer's website, not on Google itself.

Google Shopping aggregates product data such as prices, availability, and merchant information to help users make informed buying decisions, acting as a bridge between shoppers and online stores rather than a marketplace. This aggregated product data is surfaced across different Google products depending on how and where users search.

Scrape product data from Google Shopping

Scraping Google product results allows businesses and developers to conduct price comparison research, monitor competitors, identify market trends, track promotions, and optimize product strategies using real-world search data.

In this guide, you’ll learn how to scrape Google Shopping results and product data using SerpApi without managing scraping infrastructure like proxies, captchas, or browser automation.

Understanding Google Shopping Result Types

Depending on the search context, device, and Google surface being used, Google presents product data in several distinct formats. Each format corresponds to a different stage of product discovery and comparison and is exposed through a different SerpApi endpoint.

Google Shopping Results Standard product listings shown within Google’s Shopping (for example, google.com/shopping), displaying multiple products from different merchants with pricing and basic product details.
Immersive Product Results A detailed product view that appears after selecting a product, grouping the same product across multiple retailers and providing additional discovery features such as price comparisons, similar products, and (for certain categories) style ideas.

Google Shopping Result Page

Immersive Product Results

Video Tutorial

Prefer to watch a video? Check out the video below

https://www.youtube.com/embed/PKBAHFXfFyI?feature=oembed

Setting up a SerpApi account

First, head to the sign-up page to register an account. SerpApi offers a free plan for newly created accounts. Then, you can test your first search with our interactive playground.

SerpApi's Google Shopping API Playground

When you want to do more searches with us, please visit the pricing page.

Once you are familiar with all results, you can utilize SERP APIs with your API Key.

Part 1: Scrape Google Shopping Results

In this example, we scrape Google Shopping results for the keyword " iphone". The response includes fields such as position, title, product_link, product_id, price, extracted_price, rating, reviews, thumbnail, and immersive_product_page_token

We need immersive_product_page_token to scrape the details of the products later.

Head to the Google Shopping Results documentation on SerpApi for details.

Google Shopping API documentation

First, install the SerpApi client library.

pip install google-search-results

Set up theSerpApi credentials and search.

import serpapi, os, json

params = {
    'api_key': 'YOUR_API_KEY', # your serpapi api
    'engine': 'google_shopping', # SerpApi search engine    
    'q': 'iphone'
}

To retrieve Google Shopping Results for a given search term, you can use the following code:

results = GoogleSearch(params).get_dict()['shopping_results']

You can store Google Shopping Results JSON data in databases or export it to a CSV file.

import csv

header = ['position', 'title', 'product_link', 'product_id', 'price', 'extracted_price', 'rating', 'reviews', 'thumbnail', 'immersive_product_page_token']

with open('google_shopping.csv', 'w', encoding='UTF8', newline='') as f:
    writer = csv.writer(f)

    writer.writerow(header)

    for item in results:
        print(item)
        writer.writerow([item.get('position'), item.get('title'), item.get('link'), item.get('product_id'), item.get('price'), item.get('extracted_price'), item.get('rating'), item.get('reviews'), item.get('thumbnail'), item.get('immersive_product_page_token')])

Result in CSV format

Alternatively, you can get Google Shopping Results using Google Search API as well. Refer to the post below for a complete tutorial.

How to scrape Google search results with Python

Part 2: Scrape Google Shopping Product Data

Next, when we click on a product from the search results, we can see detailed information about the product. We can get this information using our Google Immersive Product API endpoint.

Google Immersive Product API documentation

The information we can get from this API includes:

Product specs
Real-time pricing across stores
Reviews, sentiment & media
Competitive alternatives
Google-curated consumer insights

import serpapi, os, json

params = {
    "api_key": SERPAPI_API_KEY,
    "engine": "google_immersive_product",
    "page_token": "token_from_previous_part"
}

results = GoogleSearch(params).get_dict()
print(json.dumps(results, indent=2))

The result

Google Immersive Product result

Conclusion

By using SerpApi, you can easily retrieve:

Google Shopping results for structured product comparison
Immersive product data for deeper discovery and analysis

Together, these APIs provide a scalable, reliable way to access Google product data without managing scraping infrastructure.

If you haven’t created an account with SerpApi yet, you can sign up and receive 250 free credits per month to get started.

If you have any questions, feel free to reach out at contact@serpapi.com

Hope you find this useful 🙂

If you’re interested in learning what you can do with Google product data after scraping it, check out the blog posts below:

How to Scrape Google Jobs Results

Noraina Nordin — Sat, 25 Jul 2026 11:09:32 +0000

There are thousands of job boards on the internet. It is time-consuming to search for a job on each job board. Google Jobs is a job search engine that aggregates job listings from various sources, including job boards, company career pages, and staffing agencies.

Google Jobs Result from SERP

Scraping Google Jobs Results helps you find comprehensive job listings, customized searches - focus on specific job titles, locations, companies, or job types to find the most relevant positions.

Furthermore, you can receive real-time updates on new job listings that match your criteria, analyze job market trends, salary ranges, and demand for specific skills by scraping and processing job data.

Google Jobs Results side by side from SERP and JSON result

Why use an API?

No need to create a parser from scratch and maintain it.
Bypass blocks from Google: solve CAPTCHA or solve IP blocks.
Pay for proxies and CAPTCHA solvers.
Don't need to use browser automation.

SerpApi handles everything on the backend, with fast response times under ~2.5 seconds (~1.2 seconds with Ludicrous speed) per request and without browser automation, which is much faster. Response times and status rates are shown under SerpApi Status page.

Setting up a SerpApi account

SerpApi offers a free plan for newly created accounts. Head to the sign-up page to register an account and complete your first search with our interactive playground. When you want to do more searches with us, please visit the pricing page.

Once you are familiar with all results, you can use SERP APIs with your API Key.

SerpApi's Google Jobs API documentation

Scrape your first Google Jobs results with SerpApi

Head to the Google Jobs Results from the documentation on SerpApi for details.

In this tutorial, we will scrape job results when searching with "SEO manager" keyword. The data contains: "title", "company", "location", "description", "logo", and more. You can also scrape more information with SerpApi.

Python tutorial

First, you need to install the SerpApi client library.

pip install google-search-results

Set up theSerpApi credentials and search.

from serpapi import GoogleSearch
import os, json

params = {
    'api_key': 'YOUR_API_KEY', # your serpapi api
    'engine': 'google_jobs', # SerpApi search engine    
    'gl': 'us',
    'hl': 'en',
    'q': 'SEO manager'
}

The parameters gl and hl represents the country and languages to use for the Google Jobs search. And this q is the search query you want to search.

To retrieve Google Jobs Results for a given search term, you can use the following code:

results = GoogleSearch(params).get_dict()['jobs_results']

You can store Jobs Results JSON data in databases or export it to a CSV file.

import csv

header = ['title', 'company', 'location', 'description', 'logo']

with open('google_jobs.csv', 'w', encoding='UTF8', newline='') as f:
    writer = csv.writer(f)

    writer.writerow(header)

    for item in results:
        print(item)
        writer.writerow([item.get('title'), item.get('company'), item.get('location'), item.get('description'), item.get('logo')])

Jobs List Results for SEO Manger

JavaScript Tutorial (Node.js)

First, we need to install google-search-results-nodejs:

npm i google-search-results-nodejs

Then, declare SerpApi from google-search-results-nodejs library and define new search instance with your API key from SerpApi:

const SerpApi = require("google-search-results-nodejs");
const search = new SerpApi.GoogleSearch(API_KEY);

Next, write a search query and the necessary parameters for making a request:

const searchString = "SEO manager"; // what we want to search

const params = {
  engine: "google_jobs", // search engine
  q: searchString, // search query
  hl: "en", // Parameter defines the language to use for the Google search
  uule: "w+CAIQICIKY2FsaWZvcm5pYQ", // encoded location
};

💡 Note: the uule parameter is an encoded location parameter. You can make it using UULE Generator for Google.

Wrap the search method from the SerpApi library in a promise to further work with the search results:

const getJson = () => {
  return new Promise((resolve) => {
    search.json(params, resolve);
  });
};

And finally, we declare the function getResult to loop through all pages of job results using Google's pagination method next_page_token

const getResults = async () => {
  const results = []; // array to store all scraped jobs
  ...
};

Why an array?

We will collect results from multiple pages until no further results are available.

Next, we need to use while loop to fetch all pages. Inside the loop:

We call the API
Add the job results
Look for next_page_token
Stop the loop when there is no next page

while (true) {
  const json = await getJson();
  if (!json.jobs_results || json.jobs_results.length === 0) break;
  results.push(...json.jobs_results);
  const nextToken = json.serpapi_pagination?.next_page_token;
  if (!nextToken) break;
  params.next_page_token = nextToken;
}
return results;

After we run the getResults function and print all the received information in the console with the console.dir method, which allows you to use an object with the necessary parameters to change default output options:

getResults().then((result) => console.dir(result, { depth: null }));

The example of the first result output in JSON format:

[
{
"title": "SEO / MARKETING PROJECT MANAGER",
"company_name": "Coalition Technologies",
"location": "Anywhere",
"via": "Indeed",
"share_link": "https://www.google.com/search?ibp=htl;jobs&q=SEO+manager&htidocid=MGL1DlRMDYIJ9S1TAAAAAA%3D%3D&hl=en-US&shndl=37&shmd=H4sIAAAAAAAA_xWMsQrCMBQAce0nOL3BSbARQQedSgnFiq3U7iUJzyQS80pfhv6LP2tdbriDy76r7PSULQi4F91N9temgkfX1rLsF9MUlexgBzVpYFSTcUARKiIbcH1xKY18FoI55JaTSt7khj6CImqaxZs0_zGwUxOOQSUcDsf9nI_RbjclqeCTX3Y9GhcpkPXI4COUS3jRFL36AY0OyBueAAAA&shmds=v1_AdeF8KjbnyFz4FzqsHm60hu6qka1jqoLYTCYhPYelMLNNggF9A&shem=bdslc,damc&source=sh/x/job/li/m1/1#fpstate=tldetail&htivrt=jobs&htiq=SEO+manager&htidocid=MGL1DlRMDYIJ9S1TAAAAAA%3D%3D",
"thumbnail": "https://serpapi.com/searches/6938c00da3ce841d0a59c1a2/images/449d886478e4414c3cef1330654d493a57f630269a9ef9d9924b5c21c43399a2.jpeg",
"extensions": [
"6 days ago",
"17–35 an hour",
"Work from home",
"Full-time",
"No degree mentioned",
"Dental insurance",
"Health insurance",
"Paid time off"
],
"detected_extensions": {
"posted_at": "6 days ago",
"salary": "17–35 an hour",
"work_from_home": true,
"schedule_type": "Full-time",
"qualifications": "No degree mentioned",
"dental_coverage": true,
"health_insurance": true,
"paid_time_off": true
},
"description": "WHY YOU SHOULD APPLY:\n\nCoalition Technologies is devoted to delivering clients the highest quality work while providing our team a fun, thriving, and innovative environment. Along with the opportunity for tremendous career growth and rapid advancement, CT offers:\n• The most competitive profit-sharing bonus plan in the industry, paying up to 50% of company profits to full-time employees each month!\n• A highly competitive Paid Time Off plan, promoting quality work-life balance.\n• Subsidized gym memberships to help team members feel their best.\n• Medical, dental, vision, and life insurance packages for all US-based team members.\n• International Health Insurance Reimbursement Program for all international team members, a benefit unique to Coalition.\n• Device upgrade and learning reimbursement programs.\n• Motivating career development plans with clearly defined goals and rewards.\n• Additional job-specific incentives and bonuses.\n• Plus, 100% of our team works remotely with the support of time tracking software. Our company culture specializes in supporting remote team members, and we’ve been doing so for more than a decade. CT welcomes your application, wherever in the world it's coming from!\n\nYOU SHOULD HAVE:\n• Excellent communication skills in a client-facing role.\n• Experience presenting professional materials to clients in on-camera meetings.\n• Experience with search engine optimization.\n• Experience managing Google Ads accounts (preferably Google Ads certified).\n• Project management experience (certifications preferred).\n• A solid understanding of project management methodology including the ability to identify and resolve issues, manage risk, develop detailed work plans and specifications, perform resource allocations, and run team meetings.\n• Knowledge of project management software such as Basecamp, MS Project, Visio, Sales Force, etc.\n• An understanding of web development (ability to write HTML / CSS /PHP is preferred).\n• Strong skills in interpersonal dynamics, analysis, problem-solving, negotiation, influence, facilitation, prioritization, decision-making, and conflict resolution.\n• Great attention to detail and a highly organized work style.\n• The availability to work 40 hours per week from 9:00 am to 6:00 pm PST.\n• Reliable internet and power, and a reliable computer with webcam, microphone, and speakers.\n• Demonstrated leadership capabilities with teams of 3 or more people (preferred).\n• Experience with WordPress and/or Magento (preferred).\n\nYOUR DUTIES AND TASKS:\n• Developing and executing comprehensive marketing strategies and plans to achieve business goals and objectives.\n• Monitoring and analyzing different campaign performance metrics with team leads, such as ROI, conversion rates, and customer engagement, and making data-driven recommendations when needed.\n• Managing the workflow of our SEO team by assigning tasks, following up on tasks, and making sure client work is done well and is on time and within budget.\n• Ensuring effective communication and collaboration between different marketing teams and other departments.\n• Providing regular project status updates to senior management and participating in client meetings as needed.\n• Staying informed about industry trends, emerging technologies, and best practices in marketing and SEO project management, and recommending innovative strategies and tools to enhance marketing efforts.\n• Mentoring and coaching team members, providing guidance and support in their professional development.\n• Identifying resources needed and assigning individual responsibilities.\n• Creating training materials, improving our work processes, and identifying concerns and dealing with them appropriately.\n• Reviewing deliverables prepared by the team before passing work on to Digital Producers.\n\nWe are looking for talented and diligent candidates who excel in our skills tests, and will consider these candidates even if past experience or educational background criteria aren't met.\n\nCalifornia, New York, Washington, and Colorado: starting base pay for this position ranges between $17 - $35 per hour. Compensation may vary based on factors such as experience, qualifications, skills test performance, geographic location, and seniority of the position offered. Outside of California, New York, Washington, and Colorado compensation may fall outside the above ranges.",
"job_highlights": [
{
"title": "Qualifications",
"items": [
"Excellent communication skills in a client-facing role",
"Experience presenting professional materials to clients in on-camera meetings",
"Experience with search engine optimization",
"Experience managing Google Ads accounts (preferably Google Ads certified)",
"A solid understanding of project management methodology including the ability to identify and resolve issues, manage risk, develop detailed work plans and specifications, perform resource allocations, and run team meetings",
"Knowledge of project management software such as Basecamp, MS Project, Visio, Sales Force, etc",
"Strong skills in interpersonal dynamics, analysis, problem-solving, negotiation, influence, facilitation, prioritization, decision-making, and conflict resolution",
"Great attention to detail and a highly organized work style",
"The availability to work 40 hours per week from 9:00 am to 6:00 pm PST",
"Reliable internet and power, and a reliable computer with webcam, microphone, and speakers",
"We are looking for talented and diligent candidates who excel in our skills tests, and will consider these candidates even if past experience or educational background criteria aren't met"
]
},
{
"title": "Benefits",
"items": [
"The most competitive profit-sharing bonus plan in the industry, paying up to 50% of company profits to full-time employees each month!",
"A highly competitive Paid Time Off plan, promoting quality work-life balance",
"Subsidized gym memberships to help team members feel their best",
"Medical, dental, vision, and life insurance packages for all US-based team members",
"International Health Insurance Reimbursement Program for all international team members, a benefit unique to Coalition",
"Device upgrade and learning reimbursement programs",
"Motivating career development plans with clearly defined goals and rewards",
"Additional job-specific incentives and bonuses",
"Plus, 100% of our team works remotely with the support of time tracking software",
"California, New York, Washington, and Colorado: starting base pay for this position ranges between $17 - $35 per hour",
"Compensation may vary based on factors such as experience, qualifications, skills test performance, geographic location, and seniority of the position offered"
]
},
{
"title": "Responsibilities",
"items": [
"Developing and executing comprehensive marketing strategies and plans to achieve business goals and objectives",
"Monitoring and analyzing different campaign performance metrics with team leads, such as ROI, conversion rates, and customer engagement, and making data-driven recommendations when needed",
"Managing the workflow of our SEO team by assigning tasks, following up on tasks, and making sure client work is done well and is on time and within budget",
"Ensuring effective communication and collaboration between different marketing teams and other departments",
"Providing regular project status updates to senior management and participating in client meetings as needed",
"Staying informed about industry trends, emerging technologies, and best practices in marketing and SEO project management, and recommending innovative strategies and tools to enhance marketing efforts",
"Mentoring and coaching team members, providing guidance and support in their professional development",
"Identifying resources needed and assigning individual responsibilities",
"Creating training materials, improving our work processes, and identifying concerns and dealing with them appropriately",
"Reviewing deliverables prepared by the team before passing work on to Digital Producers"
]
}
],
"apply_options": [
{
"title": "Indeed",
"link": "https://www.indeed.com/viewjob?jk=8da37b6b944ed7c9&utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
},
{
"title": "Teal",
"link": "https://www.tealhq.com/job/seo-marketing-project-manager_1fd318fe-84dc-4fab-8718-4804cac34189?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
},
{
"title": "Glassdoor",
"link": "https://www.glassdoor.com/job-listing/seo-marketing-project-manager-ct-JV_KO0,29_KE30,32.htm?jl=1009958481004&utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
},
{
"title": "Ladders",
"link": "https://www.theladders.com/job-listing/707673798828335825/seo-marketing-project-manager.htm?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
},
{
"title": "Talents By Vaia",
"link": "https://talents.vaia.com/companies/coalition-technologies/seo-marketing-project-manager-28754884/?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
},
{
"title": "Qureos",
"link": "https://app.qureos.com/jobs/seo-marketing-project-manager-1764846504670?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
},
{
"title": "BeBee",
"link": "https://us.bebee.com/job/691a89882c474926ab71dae2e946ec89?utm_campaign=google_jobs_apply&utm_source=google_jobs_apply&utm_medium=organic"
}
],
"job_id": "eyJqb2JfdGl0bGUiOiJTRU8gLyBNQVJLRVRJTkcgUFJPSkVDVCBNQU5BR0VSIiwiY29tcGFueV9uYW1lIjoiQ29hbGl0aW9uIFRlY2hub2xvZ2llcyIsImFkZHJlc3NfY2l0eSI6IkNhbGlmb3JuaWEiLCJodGlkb2NpZCI6Ik1HTDFEbFJNRFlJSjlTMVRBQUFBQUE9PSIsInV1bGUiOiJ3K0NBSVFJQ0lLWTJGc2FXWnZjbTVwWVEiLCJobCI6ImVuIn0="
},

  ...
  ...
  ...
]

This example uses Python and Node.js, but you can also use your favorite programming languages, like Ruby, Java, PHP and more.

Check out blog post below if you want to learn more about advanced filter to get specific jobs directly from your query:

Google Jobs Search Query Operators

If you have any questions, please feel free to contact me.

How to Scrape YouTube Video Results - 2026 Guide

Noraina Nordin — Fri, 24 Jul 2026 09:39:41 +0000

YouTube is the world's largest online video-sharing platform. It is the second-most visitedwebsite, with more than one billion monthly users who collectively watch more than one billion hours of video each day.

YouTube Search Result Page

YouTube hosts a vast array of content, and videos are indexed by search engines, so content creators can leverage search engine optimization(SEO) techniques to rank their videos. Furthermore, scraping YouTube videos can provide critical insights, upcoming trends, competitive analysis, and content ideas.

YouTube created a healthy platform for content creators. They applied cutting-edge technology to deter fake users from fake video view counts. Scraping YouTube videos is never easy. But with SerpApi, you don't need to worry about this. You just need to pick up our YouTube solution and grow your business.

SerpApi's YouTube Search API playground

Setting up a SerpApi account

Once you are familiar with all results, you can use the SERP APIs with your API Key.

YouTube Search API documentation

Scrape your first YouTube Video Results with SerpApi

Head to the YouTube Video results in the SerpApi documentation for details.

Python Tutorial

In this section, we will use Python to scrape and extract all coffee videos from the YouTube search results. The data contains: "position", "title", "link", "views", "channel_name", "description", "thumbnail", "published_date", and more. You can also scrape more information with SerpApi.

First, install the SerpApi client library.

pip install google-search-results

Set up theSerpApi credentials and search.

from serpapi import GoogleSearch
import os, json

params = {
    'api_key': 'YOUR_API_KEY', # your serpapi api
    'engine': 'youtube', # SerpApi search engine    
    'search_query': 'Coffee' # query
}

To retrieve the YouTube video results for a given search query, you can use the following code:

results = GoogleSearch(params).get_dict()['video_results']

You can store YouTube video results JSON data in a database or export it to a CSV file.

import csv

header = ['position', 'title', 'link', 'views', 'channel_name', 'description', 'thumbnail']

with open('youtube_video_results.csv', 'w', encoding='UTF8', newline='') as f:
    writer = csv.writer(f)

    writer.writerow(header)

    for item in results:
        print(item)
        writer.writerow([item.get('position_on_page'), item.get('title'), item.get('link'), item.get('views'), item.get('channel', {}).get('name'), item.get('description'), item.get('thumbnail', {}).get('static'), item.get('published_date')])

JavaScript Tutorial (Node.js)

You can also scrape YouTube video results using SerpApi's YouTube Video Results API with Node.js.

Just like the Python example above, you'll get structured JSON data without needing browser automation, custom parsers, or CSS selectors that may change over time. Your request won't be blocked as suspicious, and you can easily iterate through the results to extract what you need.

First, install google-search-results-nodejs package:

npm i google-search-results-nodejs

After installing the package. Set up your SerpApi credentials and define the search parameters:

const SerpApi = require("google-search-results-nodejs");
const search = new SerpApi.GoogleSearch(process.env.YOUR_API_KEY);

const params = {
  engine: "youtube",
  search_query: "star wars",
};

Next, we wrap the SerpApi search method in a promise so that we can work with the results asynchronously:

const getJson = () => {
  return new Promise((resolve) => {
    search.json(params, resolve);
  });
};

With this in place, you can retrieve all video results, including paginated results, by checking for the next_page_token and requesting additional pages:

const getResults = async () => {
  const allVideos = [];
  while (true) {
    const json = await getJson();

    if (json.video_results) {
      allVideos.push(...json.video_results);
    } else break;

    if (json.serpapi_pagination?.next_page_token) {
      params.sp = json.serpapi_pagination.next_page_token;
    } else break;
  }
  return allVideos;
};

In this line of code allVideos.push(...json.video_results), we use spread syntax to split the video_resultsthe array from result that was returned from the getJsonto function into elements and add them at the end of allVideos array.

Finally, you can display the collected results:

getResults().then(console.log);

Output

Here's the output in JSON format:

[
{
"title": "Star Wars Battlefront 2 - Funny Moments Order #66",
"link": "https://www.youtube.com/watch?v=LquShRk_3sw",
"channel": {
"name": "Jongo Phett",
"link": "https://www.youtube.com/c/JongoPhett",
"thumbnail": "https://yt3.ggpht.com/ytc/AKedOLR-k_Ubr0aJgzNu91jAQCc-vnCOpyIkASWxIbm7rQ=s68-c-k-c0x00ffffff-no-rj"
},
"publishedDate": "16 hours ago",
"views": "12K views",
"length": "10:39",
"description": "episode 66 of Star Wars Battlefront 2 Funny Moments, a montage of the funniest star wars clips in battlefront II. edited together by ...",
"extensions": ["New"],
"thumbnail": "https://i.ytimg.com/vi/LquShRk_3sw/hq720.jpg?sqp=-oaymwEcCOgCEMoBSFXyq4qpAw4IARUAAIhCGAFwAcABBg==&rs=AOn4CLAFNjI-rEeq5mmDL6I4nXgxZyId3Q"
},
{
"title": "The Most Powerful Character In All of Star Wars",
"link": "https://www.youtube.com/watch?v=JTTv8mmxoTE",
"channel": {
"name": "The Stupendous Wave",
"link": "https://www.youtube.com/c/TheStupendousWave",
"thumbnail": "https://yt3.ggpht.com/ytc/AKedOLQ0T0u6VqryQ-Z5efb1qVTcUHthiH8EamJMKDAE=s68-c-k-c0x00ffffff-no-rj"
},
"publishedDate": "10 hours ago",
"views": "29K views",
"length": "12:22",
"description": "For all sponsorship and business inquiries please contact: thestupendousscrub@gmail.com Business: ...",
"extensions": ["New"],
"thumbnail": "https://i.ytimg.com/vi/JTTv8mmxoTE/hqdefault.jpg?sqp=-oaymwEcCOADEI4CSFXyq4qpAw4IARUAAIhCGAFwAcABBg==&rs=AOn4CLBdHe_wWjGruLfxz1acr-3jP0YltA"
}
...and other results
]

Check out our Paginating, Sorting, and Filtering with the YouTube API post to learn more about the YouTube sp parameter to achieve more advanced functionality with the YouTube Search API.

Interesting scraping YouTube Shorts videos? Check out our How to Scrape YouTube Shorts videos results post.

If you have any questions, please feel free to contact us.

How to Do SEO Research with Claude Desktop and SerpApi MCP

Noraina Nordin — Wed, 24 Jun 2026 15:09:47 +0000

Most SEO research workflows feel like tab management. You open Ahrefs, Semrush, or any SEO tools for keyword data, flip to Google for SERP analysis, copy results into a doc, paste context back into your AI tool, and start over. Every tool switch breaks your chain of thought.

There's a better way. By connecting SerpApi's MCP server to Claude Desktop, you can run live SERP lookups, keyword research, competitor analysis, and content gap checks inside a single chat window, without touching a browser.

This post walks through how to set it up, the prompts that make it useful, and the SEO research workflows worth building into your daily routine.

Why ask Claude for SEO data when it makes up numbers?

If you've ever asked a chatbot for search volumes or "the top ranking pages" for a keyword, you've seen the problem: it answers confidently and it's often wrong. Language models don't have a live index. They approximate it by inventing volumes, guessing at competitors, and describing a SERP from months or years ago.

That's the gap theModel Context Protocol (MCP) closes. MCP lets Claude call external tools and pull real data into the conversation. Point it at theSerpApi MCP server and Claude stops guessing about Google and starts reading the actual results page for the organic positions, the People Also Ask box, autocomplete suggestions, AI Overview citations, and more. It's all fetched in real time, structured, and ready to reason over.

So the honest answer to "Is Claude good for SEO?" is: not on its own, but impressively so once it can see live data. The model is the analyst. SerpApi is the eyes.

Before You Start

Already have SerpApi MCP connected to Claude Desktop? Skip ahead.

If not, we've covered the full setup in Connecting Web Search to Claude Desktop with SerpApi MCP. It takes about five minutes. Come back here when you're ready.

SerpApi's free plan includes 250 searches per month. It's enough to run a complete research session on a keyword before you commit to a paid plan.

SEO Research Workflows with Claude

Before the workflow, one rule that separates useful AI research from the autopilot content that floods this space: Claude fetches and analyzes and you make the calls.

Search strategy is full of judgments that didn't survive automation: whether a SERP is winnable, when "high volume" is a trap because the results are all video or Reddit. If you let the model decide all of that unsupervised, you get average output that looks like everyone else's. Keep yourself in the loop at each decision point. The prompts below are written that way: they ask Claude to surface and structure, then hand the decision back to you.

SEO research workflow with Claude

📝 The example results shown throughout this post use " natural skincare products" as the keyword, but the prompts are industry-agnostic. Swap in your own keyword, and they work just as well for SaaS, finance, travel, or any other niche.

Workflow 1: Organic SERP Analysis

Start by reading the battlefield. You want to know who ranks, what format wins, and what intent Google is actually rewarding before you commit to an angle. This step leans on SerpApi'sGoogle Search API.

Prompt:

Using the SerpApi MCP, run a Google search for [your keyword] and return the top 10 organic results. For each, give me the title, domain, and a one-line read on the content type (guide, tool, forum thread, video, etc.). Then summarize: what intent is Google rewarding, what formats dominate, and is there a content type that's missing?

Read the output like a competitor would. A few things to look for:

Format of the winners. If the first page is mostly YouTube and Reddit, that's a signal that long-form may be underserved, which is an opening, not a wall.
Intent mismatch. If you planned a product page but the SERP is all how-to guides, the SERP is telling you what it wants.
Who owns the topic. A single authoritative guide ranking #1 is a different challenge than ten thin posts splitting the results.

Don't skip the reading and let Claude declare a winner. The pattern you notice here shapes everything downstream.

Top-10 organic SERP results with a content type for each result

Workflow 2: Autocomplete for Keyword Clusters

Google Autocomplete shows how people actually phrase their searches. It's where you find the modifiers, the long-tail variants, and the sub-intents worth their own sections. SerpApi exposes this through theGoogle Autocomplete API.

Prompt:

Using the SerpApi MCP autocomplete engine, pull suggestions for [your keyword] and 2–3 close variants. Group the results into thematic clusters (e.g. setup, comparisons, use cases, pricing). Flag which clusters look like separate articles versus sections within one piece.

The grouping is the value. A flat list of fifty suggestions is noise; three or four clusters are a content plan. Watch for the dominant modifiers; they tell you what shape of content the audience expects. (For a tooling topic, for instance, words like "skill," "prompt," "audit," and "agent" recurring across suggestions signal that people want repeatable workflows, not theory.)

Raw autocomplete suggestions grouped into thematic keyword clusters

Workflow 3: People Also Ask Mining

The People Also Ask (PAA) box is a direct readout of the questions Google associates with your topic and is available via theGoogle Related Questions API. Each one is a candidate subheading, an FAQ entry, or an answer block that can earn a featured snippet or an AI citation. Because PAA often surfaces content from pages ranking outside the top 10, it can put you on page one even when your main ranking isn't there yet.

Prompt:

Using the SerpApi MCP, pull the People Also Ask questions for [your keyword]. Group them by sub-theme, and for each, tell me whether it belongs as an H2 in the main article, an FAQ entry, or its own page.

Two things make PAA mining pay off.

Answer the highest-intent questions early and plainly. A clean, self-contained answer near the top of your page is exactly what both featured snippets and AI Overviews pull from.
Use the leftover questions to seed an FAQ section that mirrors how people actually ask, in their own words.

PAA questions classified into main-article H2, FAQ entries, and standalone pages

Workflow 4: Google Trends for Topic Momentum

Google Trends tells you when and whether the audience for your topic is growing or shrinking before you invest in it.

SerpApi exposes three Google Trends API data types that are useful at different stages of research.

Google Trends Interest Over Time API: shows interest over time and answers questions such as "is this topic rising, peaking, or fading?"
Google Trends Related Queries API: surfaces rising queries. For example, terms that have recently seen significant growth in search volume but don't yet have much content competing for them. That's where early-mover opportunities live.
Google Trends Trending Now API: While TIMESERIES and RELATED_QUERIES are strategic tools for planning ahead, Trending Now is tactical. It shows what's spiking in real time across Google Search, updated continuously, with search volume and the related queries driving each spike. For content teams, it's newsjacking radar.

Prompt for trend validation:

Using the SerpApi MCP with engine "google_trends" and data_type "TIMESERIES", compare these terms over the past 12 months: [your keyword], [close variant 1], [close variant 2]. Summarize the trajectory of each — is interest growing, flat, or declining? Are there seasonal patterns? Based on the pattern, what does the timing suggest for publishing?

What to look at in the output:

You want to know whether you're writing into a rising wave, a fading one, or a predictable seasonal cycle. A seasonal pattern is a publishing strategy. A declining trend is a reason to rethink the angle. Stable but flat means the audience exists — the question is whether you can take share.

Prompt for rising related queries:

Using the SerpApi MCP with engine "google_trends" and data_type "RELATED_QUERIES", pull rising queries for [your primary keyword] over the past 12 months. List the rising results separately from the top results, sorted by growth rate. For each, tell me whether it looks like a content opportunity, a competitor signal, or noise.

Rising related queries surfaced through SerpApi MCP

The rising list is your editorial calendar in early form. Terms growing 50–100% over 12 months represent topics your audience is just starting to search — meaning little content exists yet and ranking potential is high for whoever publishes first.

Prompt for real-time topics:

Using the SerpApi MCP with engine "google_trends_trending_now" and geo "US", return the top trending searches right now. For each trend, show the query, search volume, increase percentage, category, and the top 3 related breakdown queries. Flag any that are relevant to [your industry or topic] and suggest a reactive content angle for each.

Google Trends Trending Now surfaced through SerpApi MCP

Trending Now is most useful when you have a content workflow that can publish the same day. What's trending at 9 a.m. may be gone by noon. It's less relevant for evergreen articles, but valuable for reactive pieces tied to product launches, seasonal events, or breaking news in your space.

Workflow 5: From Data to a Content Brief

Now synthesize. You've got the competitive landscape, the keyword clusters, the questions, and the trends signal. Hand it all back to Claude and ask it to build the brief.

Prompt:

Based on the organic results, autocomplete clusters, PAA questions, and Trends data we just pulled, draft a content brief: (1) a recommended angle that targets a gap in what currently ranks, (2) a suggested H1, (3) an outline of H2s that covers the clusters and answers the top questions, and (4) 3–5 supporting keywords to use naturally. For each recommendation, point to the specific data that justifies it.

The "justify it with the data" instruction matters. It keeps Claude grounded in what you pulled rather than drifting into generic SEO advice. You review, you adjust, you decide. The brief is a draft of your thinking, not a replacement for it.

If you've been following along with a real keyword, you'll notice this article was built with exactly this workflow. The process is reproducible, and you just watched it run.

Researching for the AI-search era (GEO/AEO)

Here's the part that's quietly becoming the whole game. Ranking in classic blue links is no longer the only target. You also want to be the source that AI Overviews, ChatGPT, Perplexity, and Claude itself cite when they answer a question. That discipline goes by a few names: generative engine optimization (GEO) or answer engine optimization (AEO).

SerpApi gives Claude something most setups can't here: access toGoogle AI Overview data, including which sources get cited for a query. (For the conversational side of AI search, there's also theGoogle AI Mode API.) That turns "how do I get cited?" from a guess into a research question.

Prompt:

Using the SerpApi MCP, pull the AI Overview for [your keyword] and list the sources it cites. What do those sources have in common — format, depth, structure? Then compare to my page at [URL] and tell me what's making them citeable that I'm missing.

AI Overview sources compared against your page to find the citeability gap

Citeable content tends to share traits: clear, self-contained answers; specific data; structure a model can parse. Researching the citation pattern for your own topics rather than reading generic GEO advice is where the real edge is, and it's a capability the video tutorials dominating this SERP can't easily demonstrate.

What This Replaces and What It Doesn't

This setup is excellent for: SERP analysis, content ideation, competitor research, PAA mining, trend monitoring, and building content briefs.

It doesn't replace dedicated keyword research tools like Ahrefs or Semrush for volume data, KD scores, and traffic potential. Those require a separate tool with their own indexed databases. The best workflow pairs both: use Ahrefs (or your preferred keyword tool) to validate search volume and difficulty, and use Claude + SerpApi for the qualitative SERP analysis that keyword tools don't give you.

The combination is a lean, powerful research stack that lives entirely inside Claude.

Going Further

This research workflow is one slice of what the connection makes possible. For more workflows in the same vein, seethe top 5 practical use cases for the SerpApi MCP server. And when you're ready to move from a chat window to something automated such as a daily competitor-monitoring agent, the same MCP works in developer environments too: there are guides forintegrating SerpApi MCP into a developer workflow and forbuilding an AI agent with the Claude Agent SDK.

FAQ

Is Claude good for SEO? On its own, it's a strong writing and analysis partner, but an unreliable source of search data; it will approximate volumes and SERPs. Connected to live data through an MCP server like SerpApi, it becomes genuinely useful for research because it reasons over real results rather than guessing.

Which AI is best for SEO? There's no single winner; it depends on the job. Claude is particularly strong for long-context analysis, reading multiple competitor pages, transcripts, or large datasets in one pass, and for structured reasoning. What matters more than the model is whether it's connected to real SERP data and whether you keep your own judgment in the loop.

How do I use Claude specifically for SEO research? Connect it to a live data source via MCP, then run a structured session: read the organic SERP, mine autocomplete for clusters, pull People Also Ask questions, and synthesize those into a brief. Treat Claude as the analyst who fetches and structures, and make the strategic calls yourself.

Is SEO dead or evolving in 2026? Evolving, not dead. The demand for trustworthy, authoritative content hasn't gone anywhere. What's changed is that visibility now spans both traditional rankings and AI-generated answers. Research workflows that account for citeability, not just keywords, are how you stay visible.

Conclusion

Claude Desktop + SerpApi MCP turns a general-purpose AI assistant into a live SEO research tool. The setup takes five minutes. The prompts above cover the core research tasks you do before and during content creation. And because everything runs in one chat window, you keep the context that gets lost when you're jumping between tools.

Real Estate Data API for PropTech Developers

Noraina Nordin — Tue, 23 Jun 2026 15:07:57 +0000

A few years ago, I moved to Zaragoza, Spain. A city that I'd never set foot in before. I spend hours on Google Maps manually searching for "gyms near [address]," "restaurants near [address]," "metro stations near [address]" — trying to piece together which neighborhoods were safe, convenient, and actually livable.

I was doing the job that PropTech platforms should be provided.

I picked an apartment that looked good on the real estate platform. Within a year, I moved again. This time, to a neighborhood I'd discovered after being there in person. The stress of moving twice? I wouldn't wish that on anyone.

The users, especially those relocating to unfamiliar cities, are facing this exact problem every day. And every time they leave your platform to research neighborhoods on Google Maps, you've lost them.

The platforms winning right now aren't the ones with the most listings. They're the ones delivering location intelligence at scale that automatically enriches every property with the context users need to make confident decisions.

This is the opportunity. And this is how to build it.

Digital Ecosystem Demand Location Intelligence

According to Fine Magazines, in 2025, real estate platforms function as digital ecosystems, offering AI-driven recommendations, virtual tours, and neighborhood insights all in one place. Users expect to browse listings, explore neighborhoods, and make decisions without leaving the platforms.

But building these ecosystems requires data. Specifically, structured location data that can power recommendations, extract nearby amenities, and provide neighborhood context at scale. That's where a real estate data API stack comes in.

The Property Research Problem No One Talks About

My Zaragoza experience isn't unique. There are millions of users relocating every year to cities they've never visited. They need neighborhood context. And right now, most PropTech platforms can't deliver it.

Here's what most PropTech founders won't admit publicly: their 'neighborhood data' is a patchwork of manual research, outdated datasets, and educated guesses.

"Finding that data fragmentation, inconsistent quality, and high access cost remain major stumbling blocks across UK, USA, China, and India"

A 2025 report from Warwick Business School

Without a scalable real estate data API solution, the symptoms show up everywhere:

Listing goes live half-empty. Square footage? Check. Photos? Check. What's within walking distance? "TBD"
Users bounce. Every time a buyer or renter opens a listing, they need to confirm the location and the nearby area on Google Maps, GreatSchools, or Reddit to fill in the gaps your platform left; you've lost their attention. Worse, you've trained them to see your platform as incomplete. The platform winning today keeps the user experience inside. Surfacing school ratings, transit times, and local amenities without forcing users to research for themselves.
Your team becomes a bottleneck. Every new market you enter means more manual research. More hours. More inconsistency. Your growth is literally capped by how many browser tabs your team can keep open.
Address data is a mess. User types "123 Main St", twelve different ways. Your database has duplicates, typos, and listings that don't actually exist. Search becomes unreliable. Trust erodes.

Meanwhile, your competitors, who are the ones raising bigger rounds and signing enterprise deals, have already solved this problem. They've built a real estate data API stack that automates what your team still does manually.

What Winning PropTech Platforms Do Differently

The platforms pulling ahead aren't working harder. They're not hiring armies of researchers. They've built a real estate data API stack that powers automated location intelligence across their entire infrastructure.

Think about what users like me actually needed when apartment hunting:

Nearby amenities: Grocery stores, gyms, restaurants, and parks within walking distance.
Public transport access: Tram or metro stations, bus lines, and commute times.
Neighborhood quality: Is this area lively or dead? Safe or sketchy?
Verified addresses: Is this listing even real?

Winning platforms answer all of these questions automatically at scale for every listing.

Here's what a property listing enrichment looks like in practice:

Help users find the right location.

When users search for properties, typos and incomplete queries lead to frustration. For example, they type "Av de Goya, 90". With SerpApi's Google Maps Autocomplete API it will show you autocomplete suggestions, reducing errors, guiding them to real places, and returning coordinates which you can use for further enrichment.

Results from SerpApi's Google Maps Autocomplete Playground

What's around this property?

When a listing enters the system, it will automatically be tagged with nearby context:

Schools (with rating and distance).
Hospitals, pharmacies, and urgent care facilities.
Public transit stops and commute times.
Grocery stores, restaurants, gyms, banks, parks, and more.

With SerpApi's Google Maps API, a single API call returns ratings, reviews, exact addresses, hours, and GPS coordinates for any location.

Results from SerpApi's Google Maps Playground

The image above shows an example result from our playground. You can set the coordinates from the address and send the search query. In this example, the results show the available pharmacies around "Avenida Francisco de Goya, 90" including their details such as opening hours, full address, phone numbers and more.

What's missing here?

Users don't just want to know what's nearby, they also want to know what's not there.

No grocery store within walking distance? That's a dealbreaker for some. Only a few restaurants in the area? The neighborhood might be too quiet for other. No gyms nearby? Fitness-focus renters will look elsewhere.

With the same Google Maps API, you can send query by category and identify the gaps that matter to users. This will help them to make a better decision before they commit.

What's the distance between the home and ... ?

Users don't just want to know what's nearby; they want to know how long it takes to get there. Commute time to work, walking distance to the public transport, or driving time to the nearest school.

With SerpApi's Google Maps Direction API, you can extract travel times between any two points by car, transit, walking, or cycling.

Result from SerpApi's Google Maps Direction playground

We return structured direction data including the steps it took for every directions giving users a clear picture of their daily commute. By default, it shows the result for the best travel mode. However, you can cutomize by setting the travel_mode parameters.

Read the full tutorial on how to set up the Google Maps Directions with Python in the blog post below.

Get Accurate Route Data: Scraping Google Maps Directions

Is this a good neighborhood?

This is the question every user asks and the hardest one to answer at scale.

While this topic isn't 100% of the PropTech platform's job to judge, at least you can give users the data to decide for themselves. High-rated coffee shops, busy restaurants, and well-reviewed local services can be a good indicator of a healthy neighborhood.

With SerpApi's Google Maps Reviews API, you can aggregate user reviews and sentiment data from local businesses by extracting ratings, reviews counts,review snippets, images (if it was uploaded) price range for every restaurants and more.

Result from SerpApi's Google Maps Reviews playground

In the example above we can see the details review. Even though the review is in Spanish, SerpApi returns to you both the original language and english translation making it easy to analyze sentiment regardless of location.

Read the full tutorial on how to set up the Google Maps Reviews with Python in the blog post below.

How to scrape Google Maps Reviews

The Real Cost of Waiting

Every day your platforms run without automated location intelligence, you're:

Losing users to competitors with better real estate amenities mapping
Burning money on manual research that doesn't scale
Missing opportunities because you can't see market gaps
Building technical debt with messy address data that will haunt you later
Watching users bounce to Google Maps, Yelp and etc to do research you should have provided.

The PropTech platforms that will dominate the next decade aren't the ones with the most listings. They're the ones delivering the most context around their listing.

A robust real estate data API stack isn't a feature anymore. It's the foundation of every successful PropTech location intelligence strategy.

Why SerpApi Instead of Google Maps API Directly?

Google's Official Places API provides similar structured data, such as nearby places, reviews, and directions. So why use SerpApi?

Key Differences

Factor	Google Maps Platform	SerpApi
Pricing Model	Pay-per-request with
tiered volume discount	Flat monthly plans
Cost	Variable. Depends on usage
mix and SKUs	Fixed monthly cost
Data availability	Some browser-visible

Note on Popular Time: If you've ever looked at a business on Google Maps and seen the bar chart showing when it's the busiest, that's "Popular Time" data. It's valuable for PropTech platform (imagine showing users when nearby gyms or coffee shops are crowded). Google's official API does not expose this data. SerpApi returns it through the place_results endpoint requiring a second API call using the place_id from your initial local_results search. While it's an extra step, the data itself is available and structured as a busyness_score per hour for each day of the week.

Note on FieldMask: Google's Places API (New) requires you to specify exactly which fields you want in every request using X-Goog-FieldMask. Different fields fall into different pricing tiers (Essentials, Pro, Enterprise) so requesting reviews costs more than requesting displayName. This adds complexity to both your code and your billing. With SerpApi, you get all available data in one response with predictable pricing.

When Each Makes Sense

Choose Google Maps Platform if:

You need map visualization (Maps JavaScript API)
You require official support and SLAs
You have high volume (250K+ calls) where subscription pricing is cost-effective
Enterprise requirements mandate official APIs

Choose SerpApi if:

You want simple, predictable monthly costs
You need data from multiple sources (Google + Bing + Yelp)
You want all data returned without managing field masks
You need Popular Times or other browser-visible data
You need more flexibility in how you store and use the data

Beyond Google Maps: Multiple Data Sources

SerpApi isn't limited to Google Maps. You can enrich your listings with data from multiple sources through a single API provider:

Data Source	API	Best For
Google Maps	Google Maps API	Nearby places, directions, reviews, autocomplete
Bing Maps	Bing Maps API	Alternative location data, different coverage areas
Yelp	Yelp Search API	Restaurant ratings, local business reviews, neighborhood vibe

Why Use Multiple Sources?

Richer data: Yelp has deeper restaurant and nightlife reviews; Google has broader coverage.
Redundancy: If one source lacks data for a location, another might have it.
Different perspectives: Yelp users and Google users rate businesses differently. By combining both it gives a fuller picture.
Market-specific coverage: Bing Maps may have better data in certain regions.

For example, when building a neighborhood quality score, you could combine:

Google Maps Reviews: General local business sentiment.
Yelp Reviews: Detailed restaurant and nightlife ratings.

This gives your users a more complete picture than relying on a single source.

Start Building Smarter Listings Today

The gap between a platform users trust and one they abandon isn't the number of listings; it's the context around them. Every day your platform runs without automated location intelligence, you're leaving users to do the research you should be doing for them.

The good news? You don't need a team of researchers or a complex data infrastructure to fix it. With the right API stack, you can enrich every listing automatically at scale.

SerpApi gives you structured location data from multiple resources with a simple API call. Prevent user bounce today by giving your listings the context that closes decisions.

If you have any question, contact us at contact@serpapi.com

Connecting Web Search to Claude Desktop with SerpApi MCP

Noraina Nordin — Mon, 22 Jun 2026 13:20:48 +0000

Connecting SerpApi web search to Claude Desktop gives Claude a live, structured feed of SERP data, including organic ranking positions, People Also Ask, local pack results, Google News, YouTube, Shopping, and more than 100 search engines, all queries from your chat window. And you can set it up without writing a single line of code.

This guide walks through:

What SerpApi MCP actually gives you that Claude's built-in web search doesn't, and why that matters for marketing work.
A step-by-step setup tutorial. If you can copy and paste a URL, you can finish it in under five.

Why should you connect SerpApi if LLMs already search the web?

This is the fair first question, and worth answering before you spend five minutes setting anything up.

Claude does have a built-in web search. When you ask it to "look up the best CRMs for small businesses" it will read a few pages and summarize them for you. That's useful for casual research, but there's a difference between browsing the web and using the actual search engines behind it. Claude's built-in search gives you a synthesized answer while SerpApi gives you the structured results page itself, in whichever Google product (or other engine) your question actually lives.

The gap shows up the moment you step beyond plain Google Search. We tested Claude's built-in search against the same queries, and the limits become obvious:

Google Search. Even on plain web results, Claude's built-in search summarizes pages. It doesn't show you who ranks #1 through #10, what's in the People Also Ask box, which competitor owns the featured snippet, or how the SERP looks differently in Austin vs. London. SerpApi returns those positions and SERP features as structured data.
Google Flights. Ask Claude's built-in search for "cheapest flights from New York to Tokyo next month" and you'll get a recap of articles about flight prices not actual fare data, dates, airlines, or layovers. SerpApi's google_flights engine returns the structured fare results directly.
Google Images."What does the new product packaging from [competitor] look like?" through built-in search reads pages but can't reliably surface the image grid itself. SerpApi's google_images engine returns the image SERP as data, with source URLs and dimensions.
Google Shopping. Built-in search summarizes review articles; it doesn't return the product carousel with real prices, sellers, ratings, and product IDs. For competitive product research, that's a meaningful gap.
Google News. Built-in search may pull a few recent headlines, but it doesn't give you the structured news SERP; publishers, exact timestamps, story clusters, which is what brand monitoring actually needs.
Google Local / Maps."Top dentists near me" through the built-in search reads aggregator pages. It can't simulate the local pack from a specific city the way SerpApi can with location parameters, which makes multi-city local SEO checks effectively impossible.

Comparison Claude answer without SerpApi MCP (left) and with SerpApi MCP (right)

In short:

Claude's web search tells you what the web says about a topic.
SerpApi MCP gives you direct, structured access to the search engines such as Google Search, Flights, Images, Shopping, News, Local, plus YouTube, Bing, and dozens of others.

For drafting, brainstorming, and general background research, Claude's built-in search is fine. For anything where the structure of the search results is the actual deliverable. SEO audits, content briefs based on top-ranking pages, competitive position tracking, local SEO checks across multiple cities, brand monitoring on Google News, flight or product price research, image and video research, you need real SERP data, and that's what SerpApi provides.

What You'll Be Able to Do After This Setup

Once SerpApi MCP is connected, you can ask Claude things that require a real-time SERP structure. Not just web reading:

"Pull the top 10 organic results for 'project management software' in the US, then group competitors by the angle they use in their meta descriptions and title tags."
"Check Google News for mentions of [our brand] in the last 7 days and show me the publishers, headlines, and dates."
"Look up the top 5 YouTube videos for 'SEO for SaaS': give me titles, channels, view counts, and upload dates."
"Pull every People Also Ask question for 'email marketing automation' plus the related searches at the bottom of the page, and turn them into a content brief."
"Show me the local pack results for 'dentist near me' simulated from three different cities, and tell me which businesses appear in all three."

Each of these is a real marketing task that Claude's built-in web search can't reliably handle because it depends on the structure of the SERP, not just the content of the pages it links to.

Step-by-step setup

Prerequisites (Two Things, Both Free to Start)

Before we open Claude, make sure you have these:

Claude Desktop is installed on Mac or Windows. Download it from claude.ai/download if you haven't already.
A SerpApi account. A free account gives you 205 searches per month, which is plenty to test the workflow. You can sign up at serpapi.com.

That's it. You will not be installing Node.js, Python, or any package manager. We're using SerpApi's hosted MCP server, so SerpApi runs the infrastructure for you.

A quick note on what MCP actually is:

The Model Context Protocol is an open standard that lets AI apps like Claude talk to external tools (search engines, CRMs, databases) without custom-built integrations. If you want a deeper explanation, we wrote a primer here: Model Context Protocol (MCP): A Unified Standard for AI Agents and Tools. For this tutorial, you can treat MCP as "the universal adapter that lets Claude use SerpApi."

Step 1: Grab Your SerpApi API Key

Once you're logged into SerpApi, go to your dashboard at serpapi.com/manage-api-key.

You'll see a long string labeled "Your Private API Key." Click the copy icon next to it and paste it somewhere safe for a moment; you'll need it in Step 3. Treat this key like a password; don't share it publicly.

SerpApi manage API key dashboard

Step 2: Open the Connectors Screen in Claude Desktop

Launch Claude Desktop. Then:

In the left sidebar, click Customize.
Then, click Connectors.

You'll see a list of pre-built connectors (Gmail, Google Calendar, Google Drive, etc.) at the top, and at the bottom of the page there's a button that reads Add custom connector. That's the one we want.

Claude Desktop showing the Connectors tab and Add custom connector button

Don't see the "Add custom connector" button? Make sure Claude Desktop is fully updated. Custom connectors via remote MCP are available on free, Pro, Max, Team, and Enterprise plans, but older builds of the app may not show the button. Quit Claude Desktop completely and reopen it after updating.

Step 3: Add SerpApi as a Custom Connector

Click Add custom connector. A small dialog will pop up asking for two things:

Name: type SerpApi (This is just the label you'll see in Claude; you can call it whatever you want)
Remote MCP server URL: paste this exact URL, replacing the placeholder with the API key you copied in Step 1:

https://mcp.serpapi.com/YOUR_SERPAPI_API_KEY/mcp

So if your API key were abc123xyz, the full URL would be:

https://mcp.serpapi.com/abc123xyz/mcp

Click Add.

Add custom connector dialog in Claude Desktop with SerpApi configuration filled in

That's it. You don't need to edit any JSON files, run any terminal commands, or restart your computer. Claude will register the new connector immediately.

Step 4: Verify the Connection

Back on the Connectors page, you should now see "SerpApi" in your list of connectors. Open a new Claude conversation and look for the tools/attachments icon ("+" near the message box) — SerpApi should appear in the list of available tools you can enable for the chat.

SerpApi connectors in Claude Desktop

To test it, send Claude a simple prompt like:

"Use SerpApi to search Google for 'best running shoes 2026' and give me the top 5 organic results with titles and URLs."

If everything's wired up correctly, Claude will tell you it's calling the SerpApi tool, then return real, current SERP data, not a 2025 cached guess.

Claude Desktop returning live Google search results via SerpApi MCP

You can compare the result on Claude Desktop by checking your search history on serpapi.com/searches.

Your Search on SerpApi

Five Ways Marketers Are Already Using This Setup

To save you the "okay, now what?" moment, here are five workflows that have been getting traction. We covered these in more depth in our post on the top 5 practical use cases for SerpApi MCP server in AI agents, but here's the short version tailored for marketing teams:

Real-time SERP audits. Ask Claude to pull the top 10 results for a target keyword and analyze title patterns, schema markup hints, and what the competition is doing in featured snippets.
Content brief generation. Have Claude pull People Also Ask questions, related searches, and the top 5 ranking pages for a keyword, then draft an outline that covers all of them.
Brand monitoring. Run a Google News query for your brand or a competitor weekly, and let Claude summarize coverage, sentiment, and emerging narratives.
Local SEO checks. Use Google Local results to see how your business ranks in the map pack across different cities — useful for multi-location brands.
Ad copy and creative research. Pull Google Shopping or Google Ads-style results to see how competitors describe similar products, then iterate on your own positioning.

Power-User Tip: Get Better Tool Calls With Engine Schemas

SerpApi recently added a feature where the MCP server exposes the full parameter list (called "engine schemas") for each search engine, such as Google, Bing, YouTube, etcm directly to Claude. That means Claude can pick the right parameters automatically (e.g., specifying gl=us for US results, or tbm=nws for news) without you having to know SerpApi's syntax.

If you're curious how this works under the hood and how to nudge Claude toward higher-quality tool calls, we explained the mechanics in How to use SerpApi engine schemas in SerpApi MCP to improve tool call quality.

Troubleshooting: When Things Don't Work the First Time

A few common gotchas:

"Connector failed to connect" error. Double-check that you pasted your API key into the URL correctly and that there are no spaces. The URL must be in the exact format https://mcp.serpapi.com/YOUR_KEY/mcp — note the /mcp at the end.

Claude says it doesn't have access to SerpApi. In a new chat, you may need to enable the connector explicitly using the tools/attachment menu before Claude will use it. Some marketers also find it helps to mention "SerpApi" by name in the prompt for the first few queries.

You're hitting your search limit too quickly. The free tier covers 100 searches per month. If you're testing aggressively or running this for a small team, the paid plans start at a low price and unlock thousands of searches.

The connector worked, but the answers seem stale. Make sure Claude is actually calling the tool. In the chat, you'll usually see an indicator showing the tool was invoked. If Claude is just answering from memory, prompt it more directly: "Use the SerpApi tool to search Google right now for…"

Going Beyond the Desktop App

The setup we just walked through is the no-code path. If you (or someone on your team) eventually wants to embed this kind of live-search capability into a custom AI workflow, for example, an agent that does daily competitor monitoring and posts to Slack, the same SerpApi MCP works inside developer environments too. We have walkthroughs for two of those:

Integrating SerpApi MCP into Your Developer Workflow: covers Cursor, Claude Code, and other AI-assisted IDEs.
Build an AI Agent with the Claude Agent SDK: for when you're ready to build something programmatic on top of Claude.

For the bigger picture of how the MCP server fits into SerpApi's product, the original launch announcement is still the best one-page summary.

Wrapping Up

Connecting SerpApi MCP to Claude Desktop is one of the lowest-effort, highest-leverage moves a non-technical marketer can make right now. Five minutes of setup buys you live access to Google, Bing, YouTube, and dozens of other engines from inside the same chat window where you're already drafting briefs, brainstorming campaigns, and analyzing competitors.

Once it's wired up, the limit is your prompts, not your tooling.

How to Scrape Google Autocomplete Results (2026)

Noraina Nordin — Fri, 19 Jun 2026 13:51:20 +0000

When you start typing the keyword search on Google, Google will suggest relevant keywords. There are several reasons, primarily related to research, analysis, SEO, and reputation optimization, to scrape Google Autocomplete results.

Google Autocomplete search

Why do you need to scrape the autocomplete suggestions?

By scraping Google Autocomplete keywords, you can discover popular search queries related to specific keywords or topics, and generate ideas for your blog posts, videos, etc. You can have more insights into trending topics, frequently asked questions, and more!

Google Autocomplete keywords are also an excellent source for tracking mentions, sentiments, and brand reputation. For local businesses, they will help to understand the search behavior of users in specific locations.

Solution to scrape Google Autocomplete

If you want to scrape real-time keyword suggestions in different locations and different languages, SerpApi Google Autocomplete offers high-quality APIs to support your success.

Here's what sets it apart:

Structured JSON output: Results are returned in clean, ready-to-use JSON format, so you can immediately pipe data into your app, dashboard, or content tool without any parsing headaches
Real-time data: Always reflects the latest autocomplete suggestions as they appear on Google
Location & language targeting: Easily specify country, city, and language parameters in a single API call
No maintenance required: SerpApi handles all proxy rotation, CAPTCHA solving, and Google updates on their end
Reliable uptime: No scraper breakdowns or data gaps interrupting your workflow
Simple integration: Works with any language or framework via straightforward REST API calls

Let's do some searches on our playground!

Google Autocomplete API playground

Here is a video tutorial in Python:

https://www.youtube.com/embed/7iP7caHdH6A?feature=oembed

Setting up a SerpApi account

Once you are familiar with all the results, you can use the SERP APIs with your API Key.

Google Autocomplete API documentation

Scrape your first Google Autocomplete results with SerpApi

Head to the Google Autocomplete Results from the documentation on SerpApi for details.

In this tutorial, we will scrape keyword suggestions when searching with the "star" keyword. Will Google suggest "Starbucks" or "Star Wars"...? The data contains: "value", "relevance", "type", and more. You can also scrape more information with SerpApi.

First, you need to install the SerpApi client library.

pip install serpapi

Set up theSerpApi credentials and search.

import serpapi
import os, json, csv

params = {
    'api_key': 'YOUR_API_KEY', # your serpapi api
    'engine': 'google_autocomplete', # SerpApi search engine    
    'q': 'star'
}

To retrieve Google Autocomplete Results for a given search query, you can use the following code:

client = serpapi.Client()
results = client.search(params)['suggestions']

You can store Google Autocomplete Results JSON data in databases or export it to a CSV file.

import csv

header = ['value', 'relevance', 'type']

with open('google_autocomplete.csv', 'w', encoding='UTF8', newline='') as f:
    writer = csv.writer(f)

    writer.writerow(header)

    for item in results:
        print(item)
        writer.writerow([item.get('value'), item.get('relevance'), item.get('type')])

This example uses Python, but you can also use your favorite programming languages, such as Ruby, Node.js, Java, PHP, and more.

Advanced Parameters

Let’s take a look at the Advanced Parameters, as we have gone over the localization before in other blogs:

Geographic Location and Localization parameters on SerpApi’s Google Search API

In the advanced parameters we have:cp and client for potential parameters.

When you hover over the ? near the parameter names, we see the breakdown.

For cp it states:

Cursor pointer defines the position of cursor for the query provided, position starts from 0 which is a case where cursor is placed before the query |query. If not provided acts as cursor is placed in the end of query query|.

For client it states:

Parameter used to define client for autocomplete. List of supported clients.

And this link brings us to the SerpApi page of Supported Google Autocomplete Clients:

So this is an option for the type of browser that would be queried with.

psy-ab is used in when google is opened in google chrome.

safari is used in when google is opened in safari.

firefox is used in when google is opened in firefox.

youtube origin unknown. Returns JSONP.

toolbar origin unknown. Returns XML.

Use Case

Now I went over to the SerpApi Playground and started playing with the white-listed query “coffee” and manipulating the advanced search parameters.

First I wanted to see if there was a significant difference in dataset (I copied only the first 5 results) when I changed the cursor pointer cp parameter from |query to query|

{
   "value":"coffee near me",
   "relevance":950,
   "type":"QUERY"
},
{
   "value":"coffee washington",
   "relevance":601,
   "type":"QUERY"
},
{
   "value":"coffee alexandria va",
   "relevance":600,
   "type":"QUERY"
},
{
   "value":"coffee shops near me",
   "relevance":554,
   "type":"QUERY"
},
{
   "value":"coffee table",
   "relevance":553,
   "type":"QUERY"
}

{
   "value":"coffee mate",
   "relevance":601,
   "type":"QUERY"
},
{
   "value":"coffee break",
   "relevance":600,
   "type":"QUERY"
},
{
   "value":"coffee bread",
   "relevance":555,
   "type":"QUERY"
},
{
   "value":"coffee bar",
   "relevance":554,
   "type":"QUERY"
},
{
   "value":"coffee prince",
   "relevance":553,
   "type":"QUERY"
}

There is a different response. And also within the dataset there is a “relevance” data set.

I wondered where and what the information correlated to. When I checked out the raw_html_file I saw this:

There is a relevance score that is a bit arbitrary to users, but this is how Google ranks and orders the results.Then when switching the client . Here are the top three JSON results.

Chrome:

{
   "value":"coffee near me",
   "relevance":1250,
   "type":"QUERY"
},
{
   "value":"coffee las vegas",
   "relevance":601,
   "type":"QUERY"
},
{
   "value":"coffee henderson nv",
   "relevance":600,
   "type":"QUERY"
}

Chrome-omni:

{
   "value":"coffeeholic",
   "relevance":651,
   "type":"QUERY"
},
{
   "value":"coffee near me",
   "relevance":650,
   "type":"QUERY"
},
{
   "value":"coffee bellevue",
   "relevance":601,
   "type":"QUERY"
}

Safari:

{
   "value":"coffee nearby"
},
{
   "value":"coffee near me"
},
{
   "value":"coffee richmond va"
}

FireFox:

{
   "value":"coffeeshop"
},
{
   "value":"coffeeshop in de buurt"
},
{
   "value":"coffeelicious"
}

Psy-ab:

{
   "value":"coffee<b> near me</b>"
},
{
   "value":"coffee<b> shops near me</b>"
},
{
   "value":"coffee"
}

Youtube:

{
   "value":"coffee near me"
},
{
   "value":"coffee columbus ohio"
},
{
   "value":"coffee dublin ohio"
}

Quite different results and also, the relevancy score was only prevalent in chrome and chrome-omni searches.

If you have any questions, please feel free to contact us.

DEV Community: Noraina Nordin

How to Scrape Google Flights

Who Needs the Scraped Google Flights Data?

Available Data on the Google Flights API

Flight Results

Price Insights

Basic Google Flights Data Scraping

Setting Up a SerpApi Account

Search by Airport Code

cURL implementation

Python Implementation

JavaScript Implementation

Search by city ID

Customize the Flight Search

Round-trip vs. one-way

Retrieving the returning flights

Scrape flight prices and price insights

Cabin class

Filter by airline

Stops, duration, and other filters

Flexible dates

Groups of passengers

Bonus: Deals and airport autocomplete

Frequently Asked Questions (FAQs)

Is it legal to scrape Google Flights?

How do I scrape flight prices?

How do I scrape Google Flights in Python?

How much does it cost?

Why scrape Google Flights data?

Wrapping Up

How to Scrape Google Maps Autocomplete

What Does Google Maps Autocomplete API Do

How Does the Google Maps Autocomplete API Work

What data you can extract

How to use the Autocomplete API

Step 1: Open the playground

Step 2: Enter a query and coordinates

Step 3: Run the search

cURL

Python tutorial

JavaScript tutorial

Common use cases

FAQ

Is the Google Maps Autocomplete API free?

Do I need to pass coordinates?

Can I use it as an address autocomplete API?

Can I get full place details from a suggestion?

How is this different from Google Places Autocomplete?

Documentation

Google Search Parameters (2026 Guide)

What are Google Search parameters?

The q parameter

The hl parameter

The gl parameter

The lr parameter

The cr parameter

The tbs parameter

The source parameter

The ei parameter

The ved parameter

The gs_lp parameter

The iflsig parameter

The ibp parameter

The kgmid parameter

The si parameter

The sxsrf parameter

The uule parameter

The sclient parameter

The tbm parameter

Use the safe parameter to filter explicit results

Optimize for freshness with the filter and tbs combo

Conclusion

DataForSEO vs. SerpApi

Live Search Data vs SEO Platform

Data Freshness

Do you actually need real-time data?

DataForSEO pricing vs. SerpApi pricing

Ease of Integration

SerpApi

DataForSEO

The `q` parameter

The `hl` parameter

The `gl` parameter

The `lr` parameter

The `cr` parameter

The `tbs` parameter

The `source` parameter

The `ei` parameter

The `ved` parameter

The `gs_lp` parameter

The `iflsig` parameter

The `ibp` parameter

The `kgmid` parameter

The `si` parameter

The `sxsrf` parameter

The `uule` parameter

The `sclient` parameter

The `tbm` parameter

Use the `safe` parameter to filter explicit results

Optimize for freshness with the `filter` and `tbs` combo

Why need to look for `a-section a-spacing-base desktop-grid-content-view`?