# Google Hotels API — Live Rates per Stay

> Google Hotels API: a city and your dates return properties with nightly price, total, rating, type and amenities. $0.002 per delivered property.

[Home](https://quanticdata.io/)/[Collectors](https://quanticdata.io/collectors/)/*Google Hotels API*

# Google Hotels API

The Google Hotels API takes a destination and your dates and returns the properties as rows: nightly price, total for the stay, currency, rating and review count, property type and amenity chips. Rates are read live for those exact dates — $0.002 per delivered property.

[Get my free API key](https://app.quanticdata.io/register) [See the request](/collectors/google-hotels-api/#integration)

$0.002 per delivered property · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/hotels/run

```
$ curl $QD/hotels/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{ "location": "Rome, Italy",
          "check_in_date": "2026-09-18",
          "check_out_date": "2026-09-20",
          "adults": 2, "currency": "EUR" }'
{ "status": "done", "count": 20,
  "results": [
    { "name": "Hotel Artemide", "price": "€245",
      "price_value": 245, "total_price": "€490",
      "rating": 4.7, "reviews": 5120,
      "property_type": "Hotel",
      "amenities": ["Free Wi-Fi", "Spa"] } ],
  "cost": 0.04 }
# 20 properties × $0.002 · nothing delivered, nothing charged
```

**$0.002 / property**1,000 properties on the free $2 every month

**City + dates**rates priced for the exact stay you asked for

**Up to 50 properties**per run, with amenities and totals

**Multi-OTA view**Google aggregates rates instead of one booking site

On this page: [What it is](/collectors/google-hotels-api/#what) [Output fields](/collectors/google-hotels-api/#output) [Inputs](/collectors/google-hotels-api/#input) [Pricing](/collectors/google-hotels-api/#pricing) [Integration](/collectors/google-hotels-api/#integration) [Use cases](/collectors/google-hotels-api/#use-cases) [Versus the alternatives](/collectors/google-hotels-api/#compare) [FAQ](/collectors/google-hotels-api/#faq)

## What the Google Hotels API returns

**Hotel prices do not exist without dates: a rate is a function of the stay.** This collector takes a destination, a check-in and a check-out date and the number of adults, and returns the property cards Google shows for that exact stay — nightly price, total, rating, property type and amenities, as typed rows.

Most hotel scrapers on the market target one booking site. Google Hotels is an aggregator across OTAs and direct rates, so one call gives you the market view for a destination rather than one channel’s view of it — the difference between "what does this OTA charge" and "what is this city priced at this weekend".

Dates are validated before any work starts: a check-out on or before check-in, or a date in the past, comes back as a 400 rather than as an empty run you paid for. Rates are read live at request time, so a run tells you what is bookable now, not what was cached last week.

A stay, not a URL *location* *check_in_date* *check_out_date* *adults* *currency* *max_results*

## What comes back for every property

Fifteen published fields, versioned. The request dates are echoed on every row, so a stored row still means something a month later.

| Field | Type | What it holds |
| --- | --- | --- |
| `name` | string | Property name. |
| `price` · `price_value` | string · number | Nightly price as shown and parsed. |
| `total_price` | string | Total for the whole stay as shown. |
| `currency` | string | Currency of the quoted rates. |
| `rating` · `reviews` | number · integer | Rating and review count. |
| `property_type` | string | Hotel, Apartment, Vacation rental… |
| `amenities` | string[] | Amenity chips shown on the card. |
| `dates` | string | Stay dates as displayed on the card. |
| `check_in_date` · `check_out_date` | string | Echo of your request — the row is self-describing. |
| `link` · `thumbnail` | string | Property link and photo. |

## Inputs: destination and dates are required

Cross-field rules are checked before the run: check-out must be after check-in, and check-in cannot be in the past.

| Input | Type | Required | What it does |
| --- | --- | --- | --- |
| `location` | string | yes | City or area — "Rome, Italy", "Austin, TX". |
| `check_in_date` | date | yes | YYYY-MM-DD, today or later. |
| `check_out_date` | date | yes | YYYY-MM-DD, after check-in. |
| `adults` | integer | no | 1–8, default 2 — occupancy changes the rate. |
| `currency` | string | no | USD, EUR, GBP… quotes come back in it. |
| `country` · `lang` | string | no | Exit geo and interface language — rates can differ by point of sale. |
| `max_results` | integer | no | 1–50, default 20. Billed on delivered properties. |

Pricing

## What live hotel rates cost

Each delivered property is $0.002. A rate-shopping job over 10 destinations, 20 properties each, for 7 stay dates is 1,400 rows — under $3 at list price. Runs that come back empty, or that a date rule rejects, cost nothing.

**$0.002**per delivered property*$2 per 1,000 delivered properties*

**1,000 properties**on the free allowance*$2 every month, no card*

**Zero rows**zero charge*blocks, captchas and retries are on us*

**−30%**on volume tiers*the catalog returns your key's price*

### Pay as you go

$0/mo

- $2 free credit / month

- 60 requests / min

- List unit prices

### Starter

$19/mo

- $15 free credit / month

- 300 requests / min

- 10% off unit prices

Most popular

### Growth

$79/mo

- $50 free credit / month

- 600 requests / min

- 20% off unit prices

### Scale

$299/mo

- $250 free credit / month

- 1,200 requests / min

- 30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other [Data API](https://quanticdata.io/web-data-api-for-ai/). Prices are launch pricing read live from the billing config — `GET /v1/scraper/collectors` returns the price your key actually pays.

Integration

## One POST, typed rows

Base URL `https://api.quanticdata.io/v1`, Bearer auth, the same key as every other Data API. Endpoint: `POST /v1/scraper/collectors/hotels/run`.

```
# Rome, two nights, two adults, prices in EUR
curl https://api.quanticdata.io/v1/scraper/collectors/hotels/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "location": "Rome, Italy",
        "check_in_date": "2026-09-18",
        "check_out_date": "2026-09-20",
        "adults": 2, "currency": "EUR", "max_results": 30 }'
```

```
import requests
from datetime import date, timedelta

BASE = "https://api.quanticdata.io/v1/scraper/collectors"
H = {"Authorization": f"Bearer {KEY}"}

# same city, one run per weekend — a rate calendar
for w in range(4):
    ci = date.today() + timedelta(days=7 * w + 5)
    r = requests.post(f"{BASE}/hotels/run", headers=H,
        json={"location": "Rome, Italy",
              "check_in_date": ci.isoformat(),
              "check_out_date": (ci + timedelta(days=2)).isoformat(),
              "adults": 2, "currency": "EUR", "max_results": 25})
    for h in r.json()["data"]["results"]:
        print(ci, h["name"], h["price"], h["total_price"])
```

```
const BASE = "https://api.quanticdata.io/v1/scraper/collectors";
const h = { Authorization: `Bearer ${process.env.QD_API_KEY}`,
            "Content-Type": "application/json" };

const res = await fetch(`${BASE}/hotels/run`, {
  method: "POST", headers: h,
  body: JSON.stringify({ location: "Barcelona, Spain",
    check_in_date: "2026-10-02", check_out_date: "2026-10-05",
    adults: 2, currency: "EUR", max_results: 40 })
});
const { data } = await res.json();
console.log(data.results.map(p => [p.name, p.price, p.rating]));
```

```
claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, from the agent:
run_collector  slug="hotels"
               input={ "location": "Rome, Italy",
                       "check_in_date": "2026-09-18",
                       "check_out_date": "2026-09-20",
                       "adults": 2, "currency": "EUR" }
```

## What people run it for

Rate data is perishable — these four uses all depend on reading it for real dates.

### Rate shopping

A hotel checks its own position against the comp set for the same stay: nightly rate, total, rating and property type, on the dates that actually matter for the pitch.

### Revenue management inputs

Run one destination across a rolling calendar of stay dates and you have a demand curve — which weekends are priced up, where the market softens.

### Travel content and tools

Build "hotels in X from €Y" pages or a deal bot on rows you can cite, with the property link and the exact dates on every record.

### Event pricing analysis

Conference and festival weekends show up as price spikes. Compare an event stay against a control weekend in the same city to size the effect.

## Collector vs OTA scrapers vs booking APIs

Why "hotel price scraper api" and "google hotels api" end up on the same shortlist.

|  | Single-OTA scrapers | Booking/affiliate APIs | This collector |
| --- | --- | --- | --- |
| View of the market | one booking site | the inventory of that partner | Google’s aggregated view for the stay |
| Access | anti-bot fights per site | partner approval and contracts | an API key |
| Dates & occupancy | yours to encode per site | supported | first-class inputs, validated before the run |
| Totals for the stay | sometimes | usually | `total_price` when shown, plus nightly |
| Billing | proxy and compute burn | commission or contract | $0.002 per delivered property |

## Supply-side feeds and the GDS route

Google's hotel products — Hotel Center, the Hotel Prices feed — exist so hotels and OTAs can submit rates into Google. Nothing there reads what others are charging, and there is no public Google API returning hotel search results.

The professional demand-side route is a GDS or OTA API: Amadeus, Sabre, Travelport, or an OTA affiliate programme. They give you bookable inventory and contracted rates, and they require commercial agreements, certification and usually demonstrated booking volume. Building a booking product: use those. Building a rate-shopping dataset: you need what the market is publicly quoting, which is a search surface.

## Limits, the date grid and the legal bit

Up to 50 properties per run for one destination-and-dates combination. The cost driver is never the property cap — it is the grid: destinations × dates × occupancies grows multiplicatively, and ten destinations across ninety days is nine hundred runs. Decide the date resolution deliberately; weekly sampling usually answers the question that daily sampling answers ten times more expensively. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Set `currency` explicitly on every call. Rates are quoted in whatever currency the visitor appears to want, so an unpinned series records exchange-rate movement as rate movement.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Google's terms restrict automated access and travel operators defend rate data energetically. Prices are not personal data. Using competitor rates to coordinate pricing rather than to compete on it is a competition-law question independent of collection. None of this is legal advice — get some for your actual use case.

## FAQ

What people ask before scraping hotel prices — dates, coverage and what a run really costs.

[Something else? Ask us →](mailto:hello@quanticdata.io)

### Is there a Google Hotels API?

Not a public one from Google. Hotel results are shown to users but not exposed as a general API, so reading them means scraping the public results — which is what this collector does, returning properties with nightly price, total, rating and amenities.

### Do I have to give dates?

Yes, and that is the point: a hotel rate only exists for a stay. Check-in and check-out are required, occupancy defaults to two adults, and the pair is validated before any work starts — check-out after check-in, check-in not in the past.

### How much does hotel price scraping cost?

$0.002 per delivered property. The $2 free monthly allowance covers about 1,000 properties, and volume tiers take up to 30% off the unit price. Empty or rejected runs are never billed.

### Does it cover vacation rentals?

The collector reads Google’s hotel results for the destination and dates you ask for; the `property_type` field tells you what each row is — Hotel, Apartment, Vacation rental — so you can filter after the fact rather than guessing from the name.

### Are prices in my currency?

Set `currency` and quotes come back in it, with `price_value` parsed as a number. Bear in mind the point of sale matters too: `country` sets the exit geo, and rates can legitimately differ between markets.

### Can I build a rate calendar with it?

Yes — loop the same destination over a series of stay dates, one run each, and store the rows with their echoed `check_in_date`. Each run is billed only on what it delivered, so a thin date returns fewer rows and costs less.

### Why are dates required rather than optional?

Because a hotel price only exists for specific dates and occupancy. A dataset of "hotel prices" without them is not a weaker dataset, it is a meaningless one — rates move with season, day of week, demand and length of stay.

### Are these rates bookable?

No. They are what Google displays publicly, which is the right input for rate shopping and benchmarking but is not contracted inventory. Selling a room needs a GDS or OTA API with an agreement behind it.

## Start with the Google Hotels API

$0.002 per delivered property, $2 per 1,000 delivered properties. $2 of free credit every month, no card — and a run that delivers nothing is never billed.

[Get my free API key](https://app.quanticdata.io/register)

Related: [All 32 collectors](https://quanticdata.io/collectors/) [Price Comparison API](https://quanticdata.io/collectors/price-comparison-api/) [Real Estate Data Scraping](https://quanticdata.io/real-estate-data-scraping/) [Google Maps Scraper API](https://quanticdata.io/collectors/google-maps-scraper-api/) [SERP API](https://quanticdata.io/serp-api/) [Documentation](https://quanticdata.io/docs/)

---

Source: https://quanticdata.io/collectors/google-hotels-api/ · Site index for AI: https://quanticdata.io/llms.txt