Rate shopping, like for like

By the end you will have a command that answers "where do I actually sit against my comp set tonight" — product by product, instead of the cheapest-rate-per-hotel table that quietly compares a flexible rate against a non-refundable one.

What you need: the hotel on your account with its comp set filled in, the Accommodation Rates feed active, and one finished import.

What it costs: nothing per run. Feed reads are not billed per request — the credits go on the imports that collect the rates.

The report everyone builds first, and why it lies

Cheapest rate per hotel, side by side. It is the obvious comparison and it fails without ever looking broken.

Here is one real night from the feed, laid out properly:

Cheapest-per-hotel reads: 411,40 · 567,40 · 1.010,90. You are 28 % below Competitor A. Good news, and false.

Competitor A does not sell a flexible rate at all. That 567,40 is non-refundable. You are comparing your cancel-any-time rate against a rate the guest cannot cancel, and calling the difference a price gap. On the product you both actually sell, there is nothing to compare — which is itself the finding, and the one that never survives a single-number report.

Two more things visible in the grid and invisible in the list:

• Competitor B's non-refundable costs more than its flexible — 2.220,90 against 1.010,90. "Non-refundable is the cheap one" is an assumption, not a rule, and here it is backwards.
• You sell nothing in the non-refundable column. Deliberate or an oversight, that is a decision to make — and you cannot make it if the report averages the gap away.

1. Get the rates flowing

Add the hotel in Accommodations and fill in its comp set — up to ten competitors. Without them this recipe prints a price list, not a comparison.

Then launch an import in Accommodation Rates and set a schedule. The feed only answers for dates an import has already covered; ask for a night nobody imported and you get a clean 404.

2. Read the right endpoint

GET /v2/feed/accommodation/{slug}/rate/v7/{date}

Use v7. The older /rate path proxies to a legacy backend and answers a different shape — a trap worth knowing about before you build a parser around the wrong one.

What comes back is { report: { [slug]: [rate, ...] } }: your hotel and every competitor in the same payload, each rate carrying a _meta block with is_primary, accommodation_name, rate_date, visitor_type and device_type.

One rate looks like this:

{
  "room_type": "Habitación Doble Estándar",
  "price_per_night": 411.4,
  "price_total": 411.4,
  "currency": "EUR",
  "meal_plan": { "breakfast": false, "half_board": false, "full_board": false, "all_inclusive": false },
  "cancellation": { "free_cancellation": true, "free_cancellation_days": null, "no_refundable": false },
  "payment": { "no_prepayment": false },
  "is_genius": false,
  "available_rooms": 1,
  "minimum_nights": 1,
  "_meta": { "is_primary": true, "accommodation_name": "Your Hotel", "rate_date": "2026-08-21" }
}

meal_plan and cancellation are the two blocks that make the whole recipe possible. Everything else is detail.

There is also ?min_rates=true, which collapses each hotel to its single cheapest rate. It is convenient, and it is exactly the shortcut this recipe argues against: it is the parameter that throws away the product mix.

3. Define what "comparable" means

Two rates are comparable when they sell the same thing. That is a board level plus a cancellation policy — BB/flex, RO/nr — and the rules live in one file so they can be argued with:

export function board(rate) {
  const meal = rate.meal_plan || {};
  if (meal.all_inclusive) return 'AI';
  if (meal.full_board) return 'FB';
  if (meal.half_board) return 'HB';
  if (meal.breakfast) return 'BB';
  return 'RO';
}

// free_cancellation decides; no_refundable is only the fallback, because a rate
// can arrive with neither flag set.
export function cancellation(rate) {
  const policy = rate.cancellation || {};
  if (policy.free_cancellation) return 'flex';
  return 'nr';
}

export const productKey = (rate) => `${board(rate)}/${cancellation(rate)}`;

Board is checked most-inclusive first because the flags stack: an all-inclusive rate also has breakfast: true, and testing breakfast first would file it as BB.

4. Build the grid, and leave the holes open

const matrix = buildMatrix(report);   // product × hotel
const standing = position(matrix);    // where you rank on each product

The one rule that matters: a missing cell stays null. Never zero, never averaged over, never filled with that hotel's price from another product. An empty cell means the competitor does not sell that product that night, and treating it as a zero is how a comp set report starts lying.

The ranking follows from it — the denominator only counts hotels that sell the product:

Breakfast · Free cancellation   #1 of 2 · you are the cheapest
Breakfast · Non-refundable      you do not sell this — 2 competitor(s) do
Room only · Free cancellation   #1 of 2 · you are the cheapest
Room only · Non-refundable      you do not sell this — 2 competitor(s) do

"#1 of 2" is a smaller and truer claim than "#1 of 3". The three-hotel comp set only has two hotels in that race.

5. Run it

node --env-file=.env index.mjs 2026-08-21
node --env-file=.env index.mjs 2026-08-21 --csv > rates.csv

The CSV gives one row per hotel and product, ready for a spreadsheet or a warehouse — still with the empty cells omitted rather than zeroed.

What happens next

• Walk a month with /rate/v7/{year}/{month} and watch a competitor open or close its flexible inventory as the date approaches. That change of product mix usually shows up before the price does.
• The same payload carries is_genius, available_rooms and minimum_nights: a competitor cheaper only on a Genius rate, or only with a three-night minimum, is not really cheaper.
• Pair it with the parity feed. Rate shopping tells you what the market charges; parity tells you whether your own channels agree with each other.