Webhooks Explained for Listing and Price Updates

Al Amin/ Author16 min read
Webhooks Explained for Listing and Price Updates

Your brokerage dashboard still shows yesterday's asking price, but the listing source already shows a reduction. An agent refreshes the page, a buyer asks which price is right, and you discover your application hasn't fetched the latest change yet.

That's the practical starting point for webhooks explained: let the source tell your application when something changes. The harder part is making sure a delayed or repeated notification doesn't put the old price back.

Why Listing Apps Outgrow Polling

Say your application checks a listing source every fifteen minutes. A price cut, a move to pending, or a newly blocked rental night can remain invisible until the next scheduled request. Refreshing the dashboard won't help if your backend still holds the previous state.

A webhook is an HTTP callback your application registers with the provider. Instead of repeatedly asking for changes, you give the provider an address where it can send them, typically as a POST containing an event name, stable event ID, timestamp, and JSON body.

A laptop screen displaying a real estate dashboard with three property listings in a modern office.

Push changes the cost pattern

Polling sends requests even when nothing changes. Webhooks concentrate traffic around actual activity, which means your receiver needs to absorb bursts rather than run a scheduler. The RenderIO polling and webhook guide is a useful companion when choosing between those patterns.

Adoption reflects their usefulness: 50% of API developer teams surveyed used webhooks in the 2025 Postman State of the API Report, as reported by Conversational Geek. Separately, Customer.io reported that webhook volume on its platform grew two to three times year over year in 2025.

  • Historical context: A listing price-history read helps explain how an asking price evolved.
  • Change notification: A webhook tells your application that it should react to a new event.
  • Delivery contract: An HTTP 2xx usually tells the sender it may stop retrying, not that pricing, search indexes, and alerts have finished.

Design for at-least-once delivery, never exactly once. That's a defensive assumption, not a promise that a provider will retry forever.

How a Webhook Push Actually Works

Polling versus webhooks for property data

Pattern Who starts the request When you learn of a change Quiet-market cost Best fit
Polling on a timer Your application Up to one full interval late Steady requests even when nothing changed Dashboards that can wait minutes
Webhook push The data provider Seconds after the event if the receiver is up Almost no traffic until something changes Price, status, availability, and booking alerts
Hybrid with reconciliation Both Fast notice plus a scheduled catch-up read A small steady load plus event bursts Records that must not drift, such as asking price and calendar

The webhook timing above describes the intended fast path, not a delivery deadline. A provider backlog, network failure, or unavailable receiver can delay notification.

The distinction is easiest to see as a request flow.

A diagram illustrating the difference between polling and webhook push, detailing the four-step process of webhook communication.

Follow a price change to your endpoint

Your application registers a public HTTPS endpoint and chooses event types, such as listing.price_changed or availability.updated. Those names are illustrative; the provider's actual event catalog determines what you can subscribe to.

When a matching change occurs, the provider opens a connection and POSTs a payload to your URL. Your application is now the HTTP server receiving the request, rather than the client making it.

Think of a mail carrier delivering registered mail. The carrier needs confirmation that you accepted the envelope, not for you to read every page and finish every task inside it before signing.

Microsoft Graph's webhook delivery documentation makes that boundary concrete: it considers a notification delivered when the endpoint returns HTTP 2xx within 3 seconds, and recommends persisting the notification in a queue and returning 202 Accepted when processing can't finish quickly enough.

Make the endpoint an ingestion boundary

The request handler should do a small, bounded amount of work:

  • Validate: Authenticate the delivery and check that its envelope is acceptable.
  • Persist: Write the accepted event to durable storage or a durable queue.
  • Acknowledge: Return the success status the sender expects.
  • Process asynchronously: Let a worker update the listing and schedule downstream work.

Don't acknowledge an event that exists only in application memory. If the process crashes immediately afterward, the sender may believe delivery succeeded while your application has nothing to process.

For a complementary walkthrough of request protection, consult Mallary.ai's webhook payload security best practices. Security checks belong before durable acceptance, not after untrusted data has triggered a workflow.

This video offers another view of the callback pattern.

A GraphQL-based product may let you configure subscriptions or shape payloads through GraphQL. When it delivers through webhooks, however, the callback is still an HTTP POST to your endpoint, with the same acknowledgement, retry, and signature concerns as a REST-configured feed. Native GraphQL subscriptions can use other transports, so GraphQL alone doesn't establish webhook delivery behavior.

What Production Senders Retry and When

Documented webhook acknowledgement and retry contracts

Sender policy Counts as success Acknowledgement window Retry ceiling
Microsoft Graph HTTP 2xx, including 202 after queueing 3 seconds on the first attempt; 10 seconds on retries Exponential backoff for up to 4 hours
Paddle live accounts HTTP 200 5 seconds Up to 60 attempts over approximately 2 days
CloudTalk Any HTTP 2xx 15 seconds Up to 50 attempts over approximately 11.5 hours
Messari HTTP 2xx only 30-second transport timeout; 1-minute overall delivery timeout 5 attempts, 1-second start, 2× backoff, 5-minute maximum interval; 429 retried, other 4xx not
Youtrust HTTP 2xx as fast as possible 1 second on the first attempt; 10 seconds on retries 8 retries at 2 minutes, 6 minutes, 30 minutes, 1 hour, 5 hours, 18 hours, 1 day, and 2 days

There's no universal webhook timeout. Read each row as a separate contract: the success status tells you what stops retries, the acknowledgement window tells you when the sender considers an attempt unsuccessful, and the retry ceiling tells you when automatic recovery ends.

Distinguish attempts from retries: a retry happens after the initial delivery attempt, and those labels aren't interchangeable. For listing data, that difference matters because a lost acknowledgement can turn one real price change into two visible deliveries, while a late retry can arrive after a newer status has already been applied.

Longer retry windows aren't permission to respond slowly

Graph combines a short initial response window with a longer retry timeout. Paddle requires a specific success status rather than accepting every successful HTTP status, so a receiver that always returns Accepted would violate that contract.

CloudTalk spreads recovery over an extended period. Its documented retry sequence starts after 5 seconds, 30 seconds, 2 minutes, 5 minutes, and 10 minutes, followed by attempts every 15 minutes. Those intervals give an unavailable receiver opportunities to recover, and they also mean old deliveries can arrive well after newer business activity. If an “available” retry lands after a “sold” event, ordering logic has to decide which listing state wins.

Messari separates transport and overall delivery timeouts, and distinguishes overload from malformed requests. Youtrust combines a particularly short initial timeout with a retry schedule extending across days. Your request handler shouldn't spend that time performing enrichment just because later attempts might allow longer.

Operational rule: Build for the shortest acknowledgement window in the integrations you actually support, not the most forgiving sender in a comparison table.

Return the status that describes the failure

Successful acceptance deserves the expected success response. HTTP 429 with Retry-After can signal overload, but only rely on it when the sender's retry policy supports that signal.

A malformed payload is a different problem. Treat 400 Bad Request as a contract or payload bug to investigate, not as a convenient request for another delivery. Messari explicitly treats other client-error responses as permanent failures, which illustrates why returning an arbitrary error can end recovery rather than prolong it.

  • Temporary capacity failure: Apply backpressure intentionally and monitor whether the sender honors it.
  • Invalid event: Record enough diagnostic context to identify the schema problem without exposing secrets.
  • Internal failure before persistence: Don't report successful acceptance.
  • Accepted event: Avoid returning an error merely because a later worker is busy.

Use the status-code reference when mapping integration responses, while keeping inbound webhook acknowledgement rules separate from outbound API errors.

Senders should use exponential backoff with jitter rather than synchronize repeated requests against an unhealthy endpoint. Even a well-behaved retry policy can produce duplicates when the receiver's response disappears in transit, so correctness depends on idempotent processing and ordering rules, not on hoping the network preserves exactly-once delivery.

How Receivers Verify Signatures and Freshness

Anyone who learns a public callback URL can send a POST to it. Without authentication, a fake price cut could look like an ordinary listing update.

Verification has separate jobs: establish origin and integrity, then establish freshness. A valid signature proves that someone with signing authority produced the signed content; it doesn't, by itself, prove that the request is recent.

The verification sequence should be explicit.

A diagram explaining how receivers verify webhook signatures and request freshness to ensure security.

Verify bytes before interpreting fields

Read the exact raw request bytes before parsing JSON. Re-serializing an object can change whitespace, escaping, or key representation, producing a different cryptographic input even when the parsed values appear identical.

A common symmetric design uses HMAC-SHA256 with a per-endpoint secret. With asymmetric signatures, the receiver instead verifies using a published public key and doesn't possess the authority to create valid signatures.

Rebuild the signed material exactly as the sender specifies. Ideally, it covers the unique message ID, delivery timestamp, and payload, preventing an attacker from substituting an unsigned timestamp around a captured body.

The webhook security reference recommends a practical 300-second replay window, alongside raw-body verification, constant-time signature comparison, and atomic event-ID recording. Apply the window to the signed delivery timestamp, not blindly to the time the underlying listing change happened, because legitimate retries can concern older business events.

Keep acceptance atomic

After authentication and freshness checks, atomically record the event ID with durable acceptance. Concurrent copies must not both create independent jobs.

An already-accepted, authenticated delivery should receive the sender's expected success response without repeating its side effects. That prevents replayed requests from doing work while avoiding unnecessary retries of legitimate duplicates.

Keep this receiver checklist visible:

  • Raw-body HMAC: Verify untouched bytes using the correct endpoint secret and constant-time comparison.
  • Timestamp window: Reject deliveries outside the allowed tolerance and keep the server clock synchronized.
  • Stored event ID: Enforce uniqueness in durable storage.
  • HTTPS only: Protect payload confidentiality in transit.
  • Schema and size limits: Bound the body and validate accepted fields before a worker acts.

Rotate secrets on a schedule and audit rejected signatures without logging credentials. Add per-tenant rate limits so a noisy subscriber can't exhaust shared processing capacity.

If you send webhooks to customer-supplied URLs, also defend against server-side request forgery, or SSRF. Block private, loopback, link-local, and cloud-metadata destinations, resolve destinations safely at connection time, and don't follow redirects.

A valid signature establishes trust in the sender. It doesn't establish that the price inside the payload is the newest price.

How Late and Duplicate Events Stay Correct

A successful webhook isn't an exactly-once transaction. Your receiver can commit a change while its HTTP response is lost, leaving the sender unable to distinguish success from failure.

Nylas's duplicate-webhook guidance describes retry-triggering conditions including a missed 10-second response window or HTTP 503. That behavior is specific to the documented integration, but the ambiguity applies broadly: retrying an uncertain delivery can repeat work that already happened.

The safe processing path must tolerate that ambiguity.

A four-step diagram illustrating how webhooks handle late or duplicate events to maintain accurate data processing.

Deduplication and ordering solve different problems

An idempotent write produces the same final result when repeated. In the worker, store the processed event ID in the same database transaction as the listing change, protected by a uniqueness constraint.

Don't mark an event processed before changing the listing. A crash between those operations would leave an event recorded as complete even though its business effect never happened. Likewise, changing the listing before separately recording completion leaves a gap in which a retry can repeat side effects.

Deduplication alone doesn't stop an older, distinct event from overwriting current state. Store a source version, or a source timestamp with documented ordering semantics, alongside the listing and make the version comparison part of the conditional database update.

  • Already processed: Skip the repeated event's side effects.
  • New event, older version: Record the outcome but leave the current listing unchanged.
  • New event, newer version: Apply the permitted fields and commit processing completion together.
  • Ambiguous ordering: Fetch authoritative current state rather than guessing from arrival order.

Prefer source versions when available. A timestamp attached to delivery is not necessarily the timestamp of the source record's latest modification.

Recovery belongs inside your system too

Geocoding, photo enrichment, and downstream API calls belong in workers. Once your endpoint has durably accepted an event, your application owns recovery from worker failures.

Use capped internal retries, then move persistent failures into a dead-letter queue with an inspection view and controlled replay. Preserve the event, failure reason, and processing history so an operator can distinguish a temporary outage from an incompatible schema.

The OWASP Webhook Security Cheat Sheet recommends delivery limits, maximum retry counts, and disabling persistently failing endpoints. Those are sender-side safeguards, not replacements for consumer-side recovery.

Correctness test: Replay a failed event after the listing has advanced. Recovery must not restore an obsolete price.

Monitor acknowledgement failures separately from worker failures. Queue depth, processing lag, stale-event counts, and dead-letter accumulation answer different operational questions.

For price, status, and booked nights, add a periodic reconciliation pull through the same version-aware update path. Transport success means durable acceptance; business success means the intended update committed safely and downstream work remains recoverable.

Listing Availability and Review Events

Consider hypothetical payloads for a property application. These field names and values illustrate a receiver contract, not a guaranteed provider schema.

Each event should have a narrow scope. A listing event can update listing fields, a calendar event can update a calendar cell, and a review event can update a review record. Sharing an ingestion pipeline doesn't mean sharing unrestricted write access.

A listing changes price and status

Say an event contains event: listing.updated, id: evt_1842, listingId, a source timestamp and version, a status change from active to pending, and a price reduction from 640000 to 615000.

The worker keys its upsert on listingId, scoped to the provider and tenant where necessary. It updates price and status only when the source version is newer than the stored listing version.

Payload detail Correct write Corrupting mistake
Newer price and status Update those listing fields Apply an older update afterward
Photos absent Preserve existing photos Replace photos with an empty collection
Description absent Preserve existing description Treat absence as an instruction to clear it

A partial event isn't a full replacement document. Treat explicit nulls according to the schema, and distinguish them from fields the sender omitted.

A rental night becomes blocked

Now suppose event: availability.changed includes propertyId, the illustrative night 2026-07-18, status blocked, and a source version. Apply this as an idempotent calendar-cell write, keyed by property and night.

A duplicate blocked event shouldn't create another reservation or increment an occupancy counter. An older available event must not reopen the night after the newer block.

Use the home-availability endpoint documentation when planning the authoritative calendar read that supports reconciliation. Keep the calendar's versioning granular enough that an unrelated night's update doesn't cause a valid change to be discarded.

A review becomes public

A hypothetical review.published event carries listingId, reviewId, rating 4.8, a public excerpt, and a source version. Insert or update by reviewId, not by delivery attempt, so retries don't double-count the review average.

A later review edit should arrive as a distinct event with a higher review version. That event can change the review, but it must never modify listing price or availability.

  • Photo ordering: Compare photo-update versions within the correct listing scope.
  • Status reversals: Pending followed by active within the same hour can be legitimate; accept the newer source state.
  • Broker alerts: Trigger price, status, value-estimate, open-house, HOA, or listing-agent notifications only after the state change commits.

Persisting an alert job alongside the update avoids emailing a broker before the new value is available to read. These event families share a handler shape: verify, enqueue, deduplicate, compare versions, and upsert the intended aggregate.

Start With One Idempotent Listing Endpoint

A narrow receiver beats a broad subscription on day one. A listing-price update exercises authentication, durable acceptance, ordering, and recovery, and it does so without forcing calendar or review rules into scope before the basics are proven.

Build in a deliberate order

  1. Expose the route. Create an HTTPS endpoint for listing.updated and restrict it to the expected method.
  2. Authenticate the delivery. Verify the raw-body signature and enforce the timestamp tolerance.
  3. Accept durably. Atomically record the inbound event and queue its work, then return 202 when the sender accepts that status.
  4. Apply conditionally. Update price and status only when the source version is newer, committing the processed ID with the change.
  5. Add recovery. Create a dead-letter view and a nightly reconciliation read before expanding to availability or reviews.

The ordering matters because each step assumes the one before it holds. Signature checks are meaningless if the body you verified is not the body you stored. Conditional application is meaningless if the processed ID commits separately from the update.

Choose webhooks when visible staleness or polling cost already hurts the product. Keep hybrid reads when a missed event could misprice an offer or reopen a booked night.

Our REST gateway uses one base URL per provider, one x-realtyapi-key header for authentication, and returns JSON responses. One API key and one integration give access to Redfin, Realtor, Airbnb, Apartments.com, Zoopla, and Rightmove, without maintaining your own scrapers; developers can get a key instantly through the Get your API key button.

Test failure before expanding subscriptions

Use the integration documentation and the in-browser playground to inspect a live listing payload before wiring a supported subscription.

  • Tampered body: Replay a saved payload with changed content and confirm rejection without writes.
  • Repeated delivery: Send the valid event twice and confirm only the intended state transition occurs.
  • Stale version: Send an older event and confirm the listing keeps its current price.

A normal delivery succeeding proves almost nothing, because at-least-once delivery guarantees the interesting cases will arrive eventually. Call the endpoint ready when these failure cases preserve the correct listing.


RealtyAPI.io offers unified access to public real-estate data for listing, pricing, and availability workflows. Visit RealtyAPI.io to inspect a payload in the playground, get an API key, and pair your idempotent webhook receiver with scheduled reads that repair drift.