Skip to content

Rate parity for booking engines and hotel groups.

We check each hotel's direct price against Booking.com, Expedia and the sellers in hotel search results it watches, and put an undercut in that hotel's queue once two reads agree. The signed webhook below posts each new rate disparity to your endpoint.

POSThttps://pms.example.com/hooks/paritydisparity.opened
Content-Type: application/json
webhook-id: ns4k8w2q7c1m9x5t3h6v0b2r8d7f4j1g
webhook-timestamp: 1791549711
webhook-signature: v1,Xq0c…e21a=
 
{
  "version": 4,
  "id": "ns4k8w2q7c1m9x5t3h6v0b2r8d7f4j1g",
  "event": "disparity.opened",
  "disparityId": "jn7cq2b1x9d8w4fzr3m6kt5v0h7s2e8a",
  "hotel": { "id": "kd72mbx0vy4p9s1c6tqh8wf3gr5n2j7e", "name": "Hotel Aurora" },
  "ota": "booking",
  "stayDate": "2026-10-16",
  "occupancy": 2,
  "currency": "EUR",
  "directPriceMinor": 18800,
  "otaPriceMinor": 17900,
  "deltaMinor": 900,
  "directPriceEurMinor": 18800, "otaPriceEurMinor": 17900, "deltaEurMinor": 900,
  "deltaPct": 4.79,
  "trust": "seen_twice",
  "findingKind": "rate_disparity",
  "evidence": { … },
  "detectedAt": "2026-10-09T12:02:00.000Z"
}

Illustrative. Hotel Aurora is fictional.

Not tied to one engine.

We take each hotel's direct price from hotel search results, so hotels on any engine are covered today.

From hotel search results

We use the price each hotel's official site shows in hotel search results (Google Hotels), for the same night and the same guests as the sellers.

Nothing to install

No access to the engine, the channel manager or the PMS, and nothing on the hotel's site. Our team sets each hotel up.

The same checks for every hotel

Whatever engine a hotel runs on, it gets the same checks, its own queue and the same alerts.

One signed event when a rate disparity opens.

Posted as JSON to each hotel's own endpoint, and versioned from the first field.

The fields

version
Always 4 today. Fields may be added under it, so ignore any you don't know.
id
This delivery's id. Every retry of it carries the same one, in the body and in the webhook-id header, so use it to skip repeats.
event
Always disparity.opened: a new undercut. It is the only event.
disparityId
The undercut's id.
hotel
The hotel's id and name in StayParity.
ota
The channel, as a lower-case slug: booking, expedia, or whichever seller the search results listed.
stayDate
The night, as YYYY-MM-DD.
occupancy
The guest count.
currency
The hotel's currency, as an ISO 4217 code such as EUR or RON. The next three fields are in it.
directPriceMinor
The hotel's direct price, in minor units of its currency.
otaPriceMinor
The channel's price, in minor units of the hotel's currency.
deltaMinor
How much less the channel charges, in minor units of the hotel's currency.
directPriceEurMinor
The hotel's direct price, in euro cents.
otaPriceEurMinor
The channel's price, in euro cents.
deltaEurMinor
How much less the channel charges, in euro cents.
deltaPct
The same gap as a percentage of the direct price, to two decimals.
trust
Always seen_twice: two reads of hotel search results at least 30 minutes apart, on the same basis, had prices within 1% of each other.
reason
now_over_threshold when an undercut already open below your thresholds has since crossed them. Absent on a new one.
findingKind
Always rate_disparity: the same room on the same terms, cheaper on the seller.
evidence
The undercut's first reading and its newest, each with both offers as read: price, source, time, room, board and cancellation terms.
detectedAt
When the undercut was first seen, in UTC.

How it's delivered

  • A POST with Content-Type application/json, to a public https URL
  • Delivered once your endpoint answers 2xx within 10 seconds
  • A 5xx or a timeout is retried, with a longer wait each time
  • A 4xx is taken as a refusal and not retried
  • Redirects are not followed, so give the final URL

Which undercuts are sent

  • Each hotel's alert rule decides the minimum gap, in the hotel's currency and in percent
  • Undercuts from the sellers the hotel watches, for the same room as the hotel, both mapped to one of the hotel's room types. One where no room is named stays in the queue and the summary email
  • One event per undercut, when it opens, and not again while it stays live
  • Each hotel can post to its own endpoint, or several to the same one

HMAC-SHA256 over the id, the timestamp and the raw body.

It follows Standard Webhooks, so the official library can check it in most languages.

webhook-id: <the payload's id>
webhook-timestamp: <unix seconds>
webhook-signature: v1,<base64 HMAC‑SHA256>
  1. 1Read three headers: webhook-id, webhook-timestamp in Unix seconds, and webhook-signature, which is v1, a comma, then the signature in base64.
  2. 2Compute HMAC-SHA256 over the id, a dot, the timestamp, a dot, then the body exactly as it arrived. The key is your secret after whsec_, decoded from base64.
  3. 3Compare the two in constant time, and refuse a timestamp too far from now, so a captured request can't be sent again.
  4. 4Each retry keeps its webhook-id and is signed afresh, with its own timestamp.

One signing secret per account signs every hotel's deliveries. An admin mints it in the portal and sees it once; minting a new one replaces it.

Verifying it in Node.js

JavaScript
import { createHmac, timingSafeEqual } from "node:crypto";

// Or let the official library do it: npm install standardwebhooks, then
// new Webhook(secret).verify(rawBody, headers) throws unless it checks out.
// rawBody: the request body exactly as it arrived, before JSON.parse.
// headers: the request headers, with Node's lower-case names.
// secret: your whole signing secret, whsec_ prefix included.
function verify(rawBody, headers, secret, toleranceSeconds = 300) {
  const id = headers["webhook-id"];
  const timestamp = Number(headers["webhook-timestamp"]);
  if (!id || !Number.isInteger(timestamp)) return false;
  if (Math.abs(Date.now() / 1000 - timestamp) > toleranceSeconds) return false;
  const key = Buffer.from(secret.replace(/^whsec_/, ""), "base64");
  const expected = createHmac("sha256", key).update(`${id}.${timestamp}.${rawBody}`).digest();
  return String(headers["webhook-signature"] ?? "").split(" ").some((entry) => {
    const [version, signature = ""] = entry.split(",", 2);
    const given = Buffer.from(signature, "base64");
    return version === "v1" && given.length === expected.length && timingSafeEqual(given, expected);
  });
}

Python, PHP, retries and testing in the webhook docs

Every property in one account.

For a hotel group, or for the hotels you bring us as a partner.

Every hotel, its own queue

Each hotel keeps its own undercuts and alert rule, and the portal switches between them.

Your team, with roles

Admins manage the team and the signing secret. Members work the queue and set the alerts.

Set up by us

Our team adds each hotel, its alert rule and your team's access. Your hotels install nothing.

Refer your hotels, or resell StayParity.

Tell us how you work with hotels, and we'll agree the terms together.

Refer

Introduce the hotels you work with. We set them up and look after them.

Resell

Offer StayParity to your hotels as part of what you already sell them.

What partners ask first.

No. We use the price hotel search results show for each hotel's official site, whatever engine it runs on.

Start your free trial

Give us your website. We'll read the next 30 nights.

No card, no install. The next 30 nights, against Booking.com, Expedia and the other big OTAs.