Zillow Bridge Interactive vs third-party Zillow APIs

Bridge Interactive is free if you qualify. Third-party Zillow APIs are paid but anyone can use them.

That is the entire decision in one sentence. The rest of this post is the detail you need to actually pick.

I have shipped against both. I have watched teams pick the wrong one and waste a quarter on approval that never came, and I have watched teams pay for a wrapper when they could have qualified for Bridge for free.

Here is how to avoid both mistakes.

Quick comparison

Who Bridge Interactive is built for

Bridge Interactive is for entities operating inside the licensed real estate ecosystem. The typical Bridge customer is one of these.

An MLS-participating brokerage that wants to display its own listings on its website.

An IDX widget vendor building tools for those brokerages.

A technology company with a formal partnership with one or more participating MLSs.

A national platform with the legal and contractual scaffolding to handle RESO data licensing.

If you can answer “yes” to one of those, Bridge is your cheapest and most defensible option. The data lineage is clean, the cost is zero, and the standardization across participating MLSs (RESO Data Dictionary 2.0) is a real engineering advantage when your product spans markets.

The Data Dictionary defines more than 1,700 fields and 3,100 lookups. Every certified MLS uses the same field names. That consistency is the reason national IDX vendors exist.

Who the third-party path is for

Third-party Zillow APIs are for everyone Bridge does not fit. That includes:

• Indie developers and side-project builders.
• AI agents, MCP servers, and LLM-driven tools that need property context.
• Lead-generation tools, real estate investor SaaS, and analytics dashboards.
• Agencies and platforms that need Zillow data without an MLS partnership.
• Teams prototyping a feature where Bridge approval would arrive after the deadline.

The trade-off is straightforward. You are consuming Zillow’s public surface through a paid wrapper, not licensed RESO data. You pay a per-credit fee. You do not get RESO-standard field names.

In exchange, you get an API key in 60 seconds and a feature shipped this afternoon.

What Bridge restricts that third parties do not

Bridge is generous in cost and careful in display. Each MLS sets its own display rules. Common restrictions you should expect.

The Zestimate is generally not part of the feed.

Photos and listing descriptions have display-context rules. You cannot always crop, recompose, or remix them.

Agent contact info often has handling rules. Some MLSs prohibit storing it past a TTL. Some prohibit pulling it into an outbound campaign tool.

Bulk export and re-syndication are usually prohibited or require additional approvals.

Caching beyond a certain TTL is restricted.

A third-party REST wrapper sits outside this licensing structure. You have more flexibility on caching, display, and remix. You also have more responsibility. Terms-of-service compliance, attribution, and any future legal exposure are on you.

What third parties cannot do that Bridge can

The flip side of the trade-off matters too.

Third-party wrappers do not give you RESO-standard field names. If your product spans markets and you need consistent schema across MLSs, the wrapper will not get you there.

Third-party wrappers do not include MLS-private data. Pocket listings, agent-only fields, agent commission splits, showing instructions, lockbox codes. None of that surfaces through a public-data wrapper. Bridge can carry it where the MLS authorizes.

Third-party wrappers are also subject to the upstream Zillow terms of use, even though you are talking to the wrapper. The wrapper does the engineering work to stay compliant, but the underlying data is not licensed RESO content. For some enterprise procurement processes, that is a hard “no”.

If you are selling into licensed brokerages or building inside an MLS contract, Bridge is usually the only acceptable answer.

The decision tree

Walk through these questions in order.

1. Are you an MLS-affiliated brokerage, an IDX vendor working for one, or a tech company with an MLS partnership?

• Yes → Apply for Bridge Interactive. It is free and the data lineage is clean.
• No → Continue.

2. Do you need Zestimates specifically?

• Yes → Third-party. Bridge generally does not expose Zestimates.
• No or maybe → Continue.

3. Can your roadmap absorb one to six weeks of Bridge onboarding?

• Yes → Bridge is still worth the wait if you qualify.
• No → Third-party.

4. Do you need RESO-standard data (cross-MLS field names, licensed lineage)?

• Yes → Bridge.
• No → Third-party.

5. Does your product need flexibility on caching, display, or AI use cases (LLM context, MCP servers, function calling)?

• Yes → Third-party.
• No → Bridge if you qualify.

If you ended on third-party, your shortlist lives in Zillow API alternatives.

A working Bridge plus third-party fallback

Some teams use both. Bridge for the core listing data inside their licensed surface, Zillapi or Apify for everything else (Zestimates, AI agent context, exploratory tools).

This is a perfectly reasonable architecture. Each system handles what it is good at.

// Pseudo-routing: Bridge for IDX, Zillapi for Zestimate
async function getPropertyForUI(zpid: string) {
  const [bridgeListing, zestimate] = await Promise.all([
    fetchBridgeListing(zpid),                              // licensed RESO data
    fetchZillapiZestimate(zpid),                           // Zestimate sub-resource
  ]);
  return { ...bridgeListing, zestimate };
}

The licensing surface stays clean. Your IDX page renders MLS-licensed content. The Zestimate widget on the side is sourced from the wrapper. Your contractual exposure stays inside the licensed lane.

A note on cost beyond the API

Bridge is “free” in the sense that Zillow does not invoice you. Your real cost is somewhere else.

MLS membership fees. RESO certification work for your data pipeline. Legal review of the data use agreement. Engineering time to map RESO fields into your internal schema. Ongoing compliance reviews.

For a brokerage that already pays MLS fees and has an IT vendor, those costs are sunk. For an independent startup, they often add up to more than a year of paying for a wrapper.

This is why I tell pre-revenue teams to ship on a third-party wrapper first. Validate the product. If it lands, the Bridge migration becomes a tractable project funded by revenue, not a blocker on launch.

A pricing reality check

I want to put rough numbers on the cost question because the marketing copy on both sides obscures it.

Bridge itself is $0 from Zillow. But your real annual spend probably looks like this. MLS dues for one MLS run $200 to $1,500 depending on the market. Multi-MLS coverage multiplies that. RESO certification engineering is a one-time cost in the $5k to $25k range if you outsource, less if your team handles it. Legal review of the data use agreement is another $1k to $5k. Compliance time is ongoing.

A wrapper API pricing comparison (per public pricing pages as of May 2026): Zillapi starts at $5/month for hobby use and scales by credits. Apify actors run somewhere around $35/month plus per-run usage. Oxylabs and similar enterprise scrapers typically start in the hundreds per month. RapidAPI listings vary wildly per seller.

For a pre-revenue indie dev, the wrapper is materially cheaper for the first year. For a brokerage that already pays MLS dues, Bridge is cheaper from day one. The crossover point is somewhere in the middle, depending on volume.

How to apply for Bridge Interactive

If you decided Bridge is the right path, the application process is roughly this.

Identify the MLSs you need data from. Bridge connects to many but not all.

Reach out to your local MLS or to your IDX vendor and request data access via the Bridge API. Bridge does not gate access directly. The MLS does.

Sign the MLS data use agreement. This usually involves attestations about how you will display, store, and refresh the data.

Get credentials. Test against a sandbox if your MLS provides one. Map RESO fields into your schema.

Go live and stay compliant. Most MLSs reserve the right to audit and revoke.

The whole flow takes one to six weeks in my experience, with the long pole being the MLS legal review.

Get started

If your answer was third-party, start here. First call in 60 seconds, 100 credits free.

If your answer was Bridge, the official Bridge Interactive site and your local MLS are the right next step.

Frequently asked questions

Is Bridge Interactive free?

Yes, Bridge Interactive itself does not charge you. The cost is qualification. You need an MLS membership, an IDX vendor relationship, or an approved technology partnership. Some MLSs charge their own fees on top.

Who can apply to Bridge Interactive?

MLS-affiliated brokerages, IDX vendors working for those brokerages, and technology companies with formal MLS partnerships. Solo developers and indie startups without an MLS relationship will not qualify.

Does Bridge Interactive include the Zestimate?

Generally no. The Zestimate is Zillow’s proprietary valuation, not standardized RESO data, so it is not in the licensed Bridge feed. To pull Zestimates programmatically, you need a third-party wrapper.

How long does Bridge approval take?

Typical onboarding is one to six weeks. The MLS reviews your application, signs the data use agreement, and provisions credentials. Speed depends on the MLS more than on Bridge.

Can I use both Bridge and a third-party Zillow API?

Yes. Many teams use Bridge for licensed listing data inside their IDX surface and a third-party wrapper for AI use cases, Zestimates, or markets where their MLS does not cover the area.

What is RESO Web API?

RESO Web API is the OData-based standard the Real Estate Standards Organization defines for MLS data exchange. Bridge is a Platinum Certified RESO Web API. Most modern MLS feeds use it instead of the older RETS protocol.

A real-world example: switching paths after Series A

Here is a pattern I have seen play out three or four times.

A founder ships an MVP on a wrapper API. They get product-market fit. They hit 5,000 active users. They raise a Series A.

Now they are talking to enterprise customers. Brokerages. PropTech buyers. Two questions come up in every conversation. “Where does your data come from?” and “Are you a licensed RESO partner?”

The wrapper got them to revenue. The wrapper does not get them to enterprise. So they start the Bridge migration.

The migration is not painful in code. The data shapes are similar enough that a thin adapter layer handles the differences. The painful part is the legal review, the MLS conversations, and the procurement requirements.

Plan for that path explicitly. If you are building something that might one day sell into licensed real estate, structure your data layer behind an interface from day one. Swap the implementation when the time comes. Do not let the wrapper-specific quirks bleed into your business logic.

The honest answer

Most builders reading this post are not going to qualify for Bridge. That is fine.

If you are pre-MLS-relationship, ship on a third-party wrapper, validate the product, and revisit Bridge once the business case justifies the legal and compliance overhead.

If you already have the MLS relationship and the legal capacity, Bridge is almost always the right call for core listing data, with a wrapper bolted on for Zestimates and AI use cases.

The only wrong answer is paralysis. Pick one, ship, iterate.

Zillapi is an independent service and is not affiliated with, endorsed by, or sponsored by Zillow Group, Inc. “Zillow” and “Zestimate” are registered trademarks of Zillow Group, Inc. “Bridge Interactive” is a Zillow Group product. Use of those marks on this site is descriptive (nominative fair use). Read our full trademark posture.