
Use JSON-LD, and pair it correctly by page type: Product plus Offer plus Place for a for-sale listing, Accommodation plus Offer for a rental, and RealEstateAgent for agent and agency pages. This combination gives you the widest support across Google’s structured data tooling and the schema.org validator, which is exactly where you should confirm your markup before it goes live.
TL;DR:
- Properly structured listings should use Product or Accommodation combined with Offer and Place, not RealEstateListing, to increase chances of rich result eligibility.
- Essential properties include price, priceCurrency, availability, address, url, and image; missing any of these risks disqualification or no rich display.
- Validate JSON-LD with Google’s tools before deployment and ensure the markup matches visible page content to prevent silent failures.
- Automate JSON-LD generation from CMS fields and inject it in the head or before the closing body tag to maintain consistency across large property feeds.
- Focus extensive schema markup on agent profiles, agency pages, and high-value listings to maximize search visibility and local search benefits.
Table of Contents
- Which schema types to use and when
- Step-by-step JSON-LD examples for sale and rental listings
- Validation, testing, and the errors that quietly break everything
- Implementing schema at scale without breaking anything
- Agent and agency markup for local visibility
- When schema moves the needle and where investments pay off
- Managed implementation as an alternative to building it yourself
- Key documentation and validation tools
- Sources
- FAQ
Which schema types to use and when
Here’s where a lot of agents and their developers waste a weekend: they find RealEstateListing on schema.org, assume it’s the obvious choice because the name matches the use case, and build their entire markup around it. It documents real fields and it exists for a reason, but Schema, and adoption across search tools still lags behind the established combination of Product or Accommodation paired with Offer and Place. If you want your listing pages to actually earn rich result treatment, lean on the pattern that’s been battle-tested, not the one that merely sounds right.
For a property that’s for sale, structure it as a Product with a nested Offer for price and availability, and a Place for the address and geo coordinates. For a rental, swap Product for Accommodation, since it carries fields built for renting: numberOfBedrooms, floorSize, amenityFeature, and leaseLength all map cleanly to how a rental listing actually reads. This isn’t a minor technicality. Google’s own guidance on structured data points to Offer and Place as the pieces that make a property listing legible to search systems, with RealEstateListing alone considered thin on its own.
A handful of properties are non-negotiable if you want any shot at rich result eligibility:
- price and priceCurrency on the nested Offer
- availability (using schema.org’s Offer availability values)
- address and geo coordinates inside Place
- url pointing to the canonical listing page
- image with at least one usable photo
Beyond those, a handful of recommended fields separate a passable listing from a genuinely well-marked one: floorSize, numberOfBedrooms, and amenityFeature for rentals in particular.
| Page type | Recommended schema | Required properties |
|---|---|---|
| For-sale listing | Product + Offer + Place | price, priceCurrency, availability, address, url, image |
| Rental listing | Accommodation + Offer | price, priceCurrency, availability, address, url, image |
| Agent profile | RealEstateAgent (or Person) | name, address, telephone, url |
| Agency/branch page | RealEstateAgent | name, address, geo, openingHoursSpecification |
Step-by-step JSON-LD examples for sale and rental listings
Pasting a broken snippet into your <head> and hoping is not a plan. Here’s a for-sale example built on Product, Offer, and Place, with the fields that actually matter.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "3-Bedroom Colonial on Maple Street",
"image": ["https://example.com/photos/maple-1.jpg"],
"sku": "MLS-104829",
"offers": {
"@type": "Offer",
"price": "649000",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://example.com/listings/maple-street-colonial"
},
"additionalProperty": {
"@type": "PropertyValue",
"name": "floorSize",
"value": "2400 sqft"
}
}
The sku field doubles nicely as your MLS number, which gives you a stable identifier when a listing gets re-synced from your feed. availability should always use one of schema.org’s defined values (InStock for active, SoldOut once it closes), never a free-text status. And priceCurrency is not optional decoration: leave it out and you risk the whole Offer being disqualified.
Rentals follow the same skeleton, swapped to Accommodation:
{
"@context": "https://schema.org",
"@type": "Accommodation",
"name": "2BR Apartment near Riverside Park",
"numberOfBedrooms": 2,
"floorSize": {
"@type": "QuantitativeValue",
"value": "950",
"unitCode": "FTK"
},
"amenityFeature": [
{"@type": "LocationFeatureSpecification", "name": "In-unit laundry", "value": true}
],
"offers": {
"@type": "Offer",
"price": "2200",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"priceSpecification": {
"@type": "UnitPriceSpecification",
"price": "2200",
"priceCurrency": "USD",
"unitText": "MONTH"
}
}
}
Rental-specific fields like numberOfBedrooms, floorSize, and amenityFeature are why Accommodation beats Product for this use case, a point covered well in this guide to real estate JSON-LD for listings, agents, and area pages.
A few placement habits matter more than they get credit for. Put JSON-LD in the <head> or just before </body>, never split across both. Reference multiple images as an array, not a single string, since a slideshow with one photo tagged looks incomplete to a crawler. Always point url at the canonical version of the page, and if your listings are generated dynamically through a templating system, confirm the rendered HTML (not just the source template) actually contains the JSON-LD block a bot would see.
Validation, testing, and the errors that quietly break everything
Skipping validation is the single most common way a well-built listing schema fails silently. Nothing throws an error message, but the rich result simply never shows up. Build the habit of running every template through this sequence before it ships:
- Paste the JSON-LD into validator.schema.org to catch structural errors and missing required fields.
- Run the live URL through Google’s Rich Results Test to check eligibility for specific search features.
- Use URL Inspection in Search Console to confirm Google’s renderer sees the same markup your validator saw.
Watch for a short list of recurring mistakes: malformed JSON from a missing comma or unescaped quote, an Offer without priceCurrency, markup injected client-side that never reaches the crawler because the page wasn’t server-rendered or prerendered, and dates written in a format other than ISO 8601 (2026-03-12, not “March 12th”). Also check that what’s marked up matches what a visitor actually sees on the page. Google treats visible-content mismatches as a policy problem, not a quirky bonus.
Pro Tip: Validate before every deploy, not just at launch. A single CMS update that renames a field can silently break structured data across thousands of listing pages overnight.
Implementing schema at scale without breaking anything
One listing is easy. Ten thousand listings synced from an MLS feed, updated hourly, is where things get interesting, and where most sites introduce errors they never notice.
- Generate JSON-LD server-side wherever possible, since Google’s own documentation treats JSON-LD rendered before the page reaches the crawler as more reliable than anything injected purely client-side.
- Treat your CMS fields for price, address, and images as the single source of truth, feeding both the visible page and the JSON-LD from the same data so the two can never drift apart.
- Use
ItemListon index and search-results pages where multiple properties are summarized, and reserve the detailed Product or Accommodation markup for individual listing pages. - Build your templating so a price change or status flip updates the structured data and the visible page in the same deploy, never one before the other.
Here’s the part most guides skip: a lot of high-performing real estate sites deliberately noindex their thin, individual listing pages once they go stale or expire, and instead put their schema and content effort into neighborhood and area pages that stick around and accumulate authority over time. It’s a trade worth making. A listing page has a shelf life measured in weeks; an area guide compounds for years.
Pro Tip: If your listing volume outpaces your ability to QA each template change, build one canonical JSON-LD generator function and reuse it everywhere, rather than hand-editing snippets page by page.
Agent and agency markup for local visibility
Listings get you into rich results. Agent and agency markup is what gets you into the knowledge panel and local pack, and it’s the piece most brokerages leave half-finished.
- Use RealEstateAgent, a LocalBusiness subtype, on agency and branch pages, since Google’s structured data guidelines call out using the most specific subtype available for these signals.
- Use Person schema on individual agent profile pages, layered with
worksForlinking back to the agency. - Include
hasCredential,sameAs(linking to verified professional or social profiles), andknowsAboutto establish an agent’s specific expertise, which validator.schema.org’s RealEstateAgent documentation covers in detail. - Add
openingHoursSpecificationandgeocoordinates on branch pages to strengthen local search and Maps behavior.
Pairing this with dedicated local SEO tactics for luxury brokers tends to compound the effect, since strong local signals and strong agent markup reinforce each other rather than working in isolation.
When schema moves the needle and where investments pay off
Not every page deserves the same level of markup effort, and pretending otherwise burns time you don’t have. Agent pages and comprehensive area guides carry organic visibility for years; a single listing page carries it for as long as the property sits on the market. Put your heaviest, most complete schema work into agent profiles, agency pages, and neighborhood and service area content, and automate the rest.
For listings themselves, reserve manual attention for canonical, high-value properties, and let templating handle status changes for everything else. The trade-off is real: more markup means more maintenance, but the upside, richer visibility in search and a better shot at inclusion in AI-generated answers, tends to reward the pages built to last, not the ones that expire in a month.
— Jason
Managed implementation as an alternative to building it yourself
Building and maintaining this yourself is entirely doable, and everything above will get you there. But if your team is juggling twelve listings a week across multiple branches, structured data maintenance becomes one more thing competing for attention against actual client work, and that’s a fair trade to hand off.

Managed implementation services handle templating, ongoing monitoring, and status updates to keep your schema accurate as listings move through the pipeline. This tends to make the most sense for:
- Multi-branch agencies juggling dozens of active listings with frequent status changes
- Teams that would rather have their marketing manager focused on client experience than debugging JSON-LD
- Brokerages that want listing and agent pages built once, correctly, and kept current without a developer on standby
If that’s where you are, our pricing and service packages lay out what a managed setup looks like, including the Marketing suite for teams that want listing optimization folded into a broader campaign strategy. Reclaim the time structured data maintenance was quietly costing you and put it back into closing deals.
Key documentation and validation tools
Bookmark these before you write a single line of JSON-LD: Google’s structured data introduction for format and eligibility rules, the RealEstateListing type page on schema.org for field definitions, and validator.schema.org for pre-launch checks. For date formatting, ISO 8601 is the standard your date fields should follow throughout.
Sources
- Intro to How Structured Data Markup Works | Google Search Central | Documentation | Google for Developers
- Schema
- Validator
FAQ
What is an example of schema markup for a property listing?
A typical example is JSON-LD using Product as the main type, with a nested Offer carrying price, priceCurrency, and availability, plus a Place for the address. The for-sale snippet earlier in this guide is a working example you can adapt directly.
What is the 7% rule in real estate?
This is a general real estate finance concept unrelated to structured data or schema markup, and it isn’t something this guide covers. If you’re researching pricing or commission rules for your market, check with a licensed professional in your area for the specific figures that apply.
What is the 3-3-3 rule in real estate?
Like the 7% rule, this refers to a general real estate practice concept, not a schema or SEO standard, so it falls outside what this article addresses. Definitions vary depending on who’s using the term, so treat any specific version you encounter with caution unless it comes from a named, credible source.
Do I need RealEstateListing schema, or is Product enough?
Product paired with Offer and Place is the more established combination for for-sale listings, since RealEstateListing is a newer schema.org type with narrower support in search tooling. You can use RealEstateListing as a supplement, but don’t rely on it alone.
How often should I re-validate my listing schema?
Re-validate any time you change your listing template, your CMS fields, or your JSON-LD generator function, not just at initial launch. Running new templates through validator.schema.org before deploying catches structural errors before they reach live pages.







