# How to Use the Playwright MCP to Pull MLS Listings for Real Estate Agents
> Wire the Playwright MCP into Claude to scrape MLS-supplied data your agent dashboard exposes, then chain with the Real Estate Vault for a fair-housing-safe CMA outline and listing description — without copy-pasting from 6 tabs.
**Author:** [Alex Lowe](https://theaicareerlab.com/about) — Founder, The AI Career Lab
**Published:** 2026-05-24
**Canonical URL:** https://theaicareerlab.com/blog/playwright-mcp-real-estate-mls-automation
**Profession:** real-estate
**Category:** how-to
**Tags:** real estate, real estate agents, MCP, Playwright, MLS, CMA, agentic AI, 2026
---A real estate agent generating a CMA today opens five things: the MLS (active comps + pendings), the public-records portal (sale history), Zillow (Zestimate sanity check), Google Maps (neighborhood context), and a blank CMA template. They cross-reference, copy, paste, format, and write the seller-facing narrative. Forty-five minutes to an hour per CMA. Three to five CMAs a week for a working listing agent.

The [Playwright MCP server](https://github.com/microsoft/playwright-mcp) — Microsoft's official MCP wrapping the Playwright browser automation framework — lets Claude do that cross-referencing in one conversation. Combined with the [Real Estate AI Cowork Vault](https://clowealex.gumroad.com/l/cqvdol), the CMA outline + listing description + seller-presentation talking points come out the other end in your voice with fair-housing checks already run.

> 💡 **The stack.** Playwright MCP automates your MLS access (you log in, Claude operates the session). The [Real Estate Vault](https://clowealex.gumroad.com/l/cqvdol) is the agentic layer that turns the data into CMA narratives, listing descriptions, and seller-presentation talking points — with the fair-housing guard running ambient. **$14 one-time** — Claude + M365 Copilot included.

## What the Playwright MCP actually does

Playwright is the modern browser automation framework (Microsoft-maintained, used by Visual Studio Code, GitHub, and most major QA stacks). The MCP server is the Anthropic-spec wrapper that exposes Playwright's actions to Claude:

- **`navigate`** — go to a URL
- **`click`** / **`fill`** — interact with elements
- **`screenshot`** — capture the current page (helpful for visual debugging)
- **`extract_text`** — pull rendered text from selectors
- **`extract_structured`** — pull structured data (tables, lists) from selectors

For real estate work, the relevant pattern is: Playwright authenticates into your MLS using your saved session, navigates to a comparable search, extracts the result table, and returns it into Claude's context.

## Pre-flight

- **Claude Cowork** (desktop) or **Claude Code**
- **Your MLS login credentials** (the Playwright MCP runs in your authenticated session — it doesn't bypass anything)
- The **[Real Estate AI Cowork Vault](https://clowealex.gumroad.com/l/cqvdol)** in your Cowork Project
- **Node.js 20+** and a Playwright browser install (the MCP installer handles this on first run)

## Configure the MCP server

```json
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@microsoft/mcp-server-playwright"]
    }
  }
}
```

Restart Claude. The Playwright MCP appears in your connectors. First call will prompt to install browser binaries (~150 MB).

## Run the MLS pull

Inside your Cowork Project:

```text
Use the Playwright MCP to:
1. Open https://flexmls.com (or your MLS portal URL)
2. Log me in — I'll handle the auth manually in the browser window
3. Once I'm in, search active + pending listings in ZIP 78704
   for single-family, 3+ beds, 1,400-1,800 sqft, listed in last 90 days
4. Extract the result table — address, list price, beds/baths, sqft, 
   days on market, status
```

The Playwright MCP opens a browser window. You log in manually (the MCP doesn't store your password; you authenticate, the session persists for the conversation). Claude then navigates the search and pulls the data into the conversation.

For follow-up CMAs in the same session, you don't re-auth — the session sticks.

## Chain it with the vault for CMA outline

You've got active listings + pendings. Combine with ATTOM (for closed sales — see the [ATTOM MCP article](/blog/attom-mcp-real-estate-agents-comps-automation)) and feed the vault:

```text
/cma-outline
Subject property: 1234 Oak St, Austin TX 78704
Subject: 3/2, 1,620 sqft, built 1978, recent kitchen update
Active comps + pendings: [paste Playwright MLS pull from above]
Closed sales (last 6 mo): [paste ATTOM pull, if running both MCPs]
Pricing strategy: aggressive — listing in spring
Target days-on-market: 7
```

The vault builds the CMA outline. Subject summary, comps with adjustments rationale, suggested price range with reasoning, days-on-market projection, talking points for the seller conversation. **The fair-housing guard fires if any comp narrative drifts into steering language.**

## Chain into listing description

Same context, next skill:

```text
/listing-description
Property: 1234 Oak St — use CMA above for details
Voice: warm, neighborhood-aware
Target buyer: dual-income, first-time buyer, walkable lifestyle
Highlight: kitchen reno, walkable to Zilker
Compliance: fair-housing safe
```

Output: a listing description with the fair-housing guard active. **"Perfect for a young family" never ships.** Neither does "great for empty-nesters" or "ideal for working professionals" — anything that could be read as steering by protected class. The guard fires *before* the draft, names the specific phrase that's a problem, and lets you re-scope.

This isn't a "we ran the listing through a checker afterward" pattern. It's ambient. You don't remember to invoke the guard; the guard invokes itself.

## Chain into the seller presentation

```text
/seller-presentation-talking-points
Listing: 1234 Oak St
Context: [CMA above]
Seller's concerns from intake: priced too high last time, want offers in week 1
Comp narrative emphasis: 2 recent closes within 0.1 miles, 1 active 3 streets over
```

You get a structured set of talking points. The "why we're priced where we're priced" narrative is in. The "what we're doing differently this time" angle is in. The "expected timeline" framing is in. You walk into the listing presentation with the seller's specific concerns already addressed.

## What this doesn't do

It doesn't republish MLS data. The Playwright pull stays in your conversation. The vault outputs (CMA outline, listing description) reference comps in standard analyst-format, not by republishing the MLS table verbatim.

It doesn't replace your CMA-builder if your MLS already has a good one. If FlexMLS or Matrix has a CMA generator you like, use it for the math; let the vault handle the seller-facing narrative.

It doesn't violate your MLS TOS unless you set it up that way. Single-user, single-session, at human pacing, on your own credentials = same as you using the MLS. Bulk-scraping or republishing = a different story; don't do that.

## Common failure modes

- **MLS portal changes layout, Playwright selectors break.** Most MLS portals do major redesigns every few years. The Playwright MCP's selectors are configurable; update them when the portal changes. Or pin to the older portal URL if your MLS still serves both.
- **Captcha during login.** Some MLSs run Cloudflare or similar. You'll see the captcha in the Playwright browser window; solve it manually, the session continues normally.
- **Fair-housing guard fires on a description you thought was fine.** Read the flag. The guard catches "professional couple" and "young family" reliably, plus some less-obvious ones ("safe neighborhood" can be a coded steering term in some markets). If you disagree, you can override — but read the flag first.
- **Comp data feels off.** Cross-reference with ATTOM. The MLS shows what's listed; ATTOM shows what's actually closed. The two should agree on closed comps; if they don't, there's a data lag somewhere worth investigating.

## When you'd skip this stack

- **You list under 12 properties/year.** Manual CMA workflow is fine; the MCP setup time isn't worth it.
- **Your MLS has a great IDX/RETS feed with API access.** Use that instead — cleaner than browser automation, no risk of TOS conflict.
- **You don't run your own listings.** Buyer-side agents need different workflows; the vault's buyer-side skills (`/buyer-consultation-recap`, `/inspection-response-negotiation`) don't need MLS automation.

## Sources

- Microsoft: [Playwright MCP server (GitHub)](https://github.com/microsoft/playwright-mcp)
- Anthropic: [Model Context Protocol (MCP) introduction](https://modelcontextprotocol.io)
- NAR: [Code of Ethics — Article 12 (fair housing)](https://www.nar.realtor/about-nar/governing-documents/code-of-ethics)
- HUD: [Fair Housing Act overview](https://www.hud.gov/program_offices/fair_housing_equal_opp/fair_housing_act_overview)
## Frequently asked questions

### Is using Playwright to scrape my MLS a violation of TOS?

Read your MLS member agreement. Most MLSs allow automation for your own access — you're authenticating as you, viewing data you're licensed to view, just programmatically. Some restrict third-party data export or downstream sharing; the Playwright MCP is for your local conversation only, not republishing. If your MLS has an official IDX or RETS feed for members, prefer that — it's cleaner than browser automation.

### Won't the MLS notice and lock my account?

Not at human pacing. The Playwright MCP runs single-session, single-user, with deliberate think-time between actions. It looks like you on a slightly faster mouse. The lock-out triggers MLSs use are tuned for bulk scraping (hundreds of concurrent requests, headless without delays), not for one logged-in agent generating CMAs.

### What about ATTOM Data — when do I use that vs Playwright?

ATTOM is for public-record data: sale history, tax assessments, parcel info. Use it for comps and pricing-trend context. Playwright is for what's *only in your MLS*: the active listings, the agent-only remarks field, the showing instructions, pendings that haven't hit public records yet. Different sources, different jobs. The Real Estate Vault's `/cma-outline` skill knows when to call which.

---

*Canonical version: https://theaicareerlab.com/blog/playwright-mcp-real-estate-mls-automation*
*This document is the Markdown companion served for AI crawlers and answer engines. See the canonical URL for the rendered version with navigation, related content, and interactive elements.*