Best real estate APIs for AI agents in 2026: a buyer's guide

You’re building an AI agent that needs property data. You ask ChatGPT to pull a Zestimate for 123 Main Street. It hallucinates a number. Your users notice.

The real estate API you pick determines whether your agent returns facts or fiction. In May 2026, six APIs offer structured U.S. property data that AI agents can call directly through function calling or MCP (Model Context Protocol). The best options return typed JSON with 150+ fields per property, authenticate with a single bearer token, and cost under $0.01 per call. Zillapi, ATTOM, BatchData, Apify’s Zillow actors, RentCast, and HouseCanary each take a different trade-off on price, coverage, agent-readiness, and MCP support. This guide breaks down exactly which one fits your stack.

Which real estate APIs actually support MCP for AI agents?

MCP lets your AI agent call a property data tool directly inside Claude, ChatGPT, or any MCP-compatible client without writing custom integration code. As of May 2026, three providers ship production MCP servers and two more have announced them. ATTOM launched its MCP server on January 29, 2026, covering 158 million U.S. properties with 55+ exposed tools. Cotality (formerly CoreLogic) followed in March 2026. BatchData published a community MCP server on GitHub with address verification, geocoding, and property lookup tools.

Zillapi takes a different approach. Instead of shipping a standalone MCP server binary, it publishes an OpenAPI 3.1 spec at /openapi.json plus llms.txt and llms-full.txt files purpose-built for context-window ingestion. Any MCP code generator (like the one in Claude Desktop or Cursor) can convert that spec into a working MCP server in under a minute.

RentCast and HouseCanary have no MCP support as of this writing.

Why does MCP matter? Because without it, your agent needs custom HTTP-calling code for every endpoint. With MCP, Claude or ChatGPT calls the API the same way it calls a calculator. One protocol, zero glue code.

How do you evaluate a real estate API for function calling?

A real estate API is function-call friendly when it meets four criteria: it uses bearer-token auth (no OAuth dance), returns flat typed JSON (no nested XML), publishes an OpenAPI 3.1 spec (so agents auto-generate tool definitions), and keeps response payloads under the context-window limit. APIs that fail on any of these force you to write middleware your agent shouldn’t need.

Here’s what I tested across the six APIs:

Bearer-token auth is standard at Zillapi (zk_ prefix keys), RentCast, and Apify. ATTOM uses API keys as query parameters. BatchData requires an API key header. HouseCanary uses HTTP Basic Auth with a key/secret pair.

OpenAPI specs are published by Zillapi (3.1), ATTOM (3.0), and RentCast (3.0). BatchData, HouseCanary, and Apify rely on narrative docs only. According to a 2025 analysis by Autobound, APIs with published OpenAPI specs produce 3-4x fewer agent errors than those with only narrative documentation.

That gap is real. I watched a Claude Code session call ATTOM’s property endpoint correctly on the first try using the spec. The same agent needed three retries on an API with docs-only.

What does the comparison table look like?

I tested all six APIs in April 2026. Here’s how they stack up on the criteria that matter most for AI agent builders.

Two things jump out.

First, the cost gap is massive. HouseCanary charges 100x more per call than Zillapi for a much smaller field set. That math gets brutal when your agent makes 10,000 calls a month.

Second, latency matters more than you think. When a user asks your AI agent a property question, they’re waiting in a chat window. A 200ms API response means your agent replies in under 2 seconds. A 5-second Apify scrape means your user stares at a spinner for 8+ seconds after LLM processing.

What about data depth versus agent simplicity?

ATTOM wins on raw data depth with 9,000+ attributes per property. Tax history, foreclosure records, neighborhood demographics, flood zones, school ratings. If your agent needs environmental risk scoring or historical owner chains, ATTOM is hard to beat.

But 9,000 attributes comes with a cost: deeply nested JSON responses that eat context-window tokens. A single ATTOM property response can exceed 15,000 tokens.

Zillapi returns 300+ fields in flat typed JSON. That’s enough for Zestimates, tax data, photos, price history, nearby comparables, school ratings, and listing status. A typical response runs 2,000-3,000 tokens. Your agent gets the answer and still has room to think.

RentCast is the minimalist option at 75+ fields focused on valuations and rental estimates. Clean responses, fast, but limited if your agent needs photos or listing details.

I’d frame it this way: ATTOM is for enterprise agents that need everything. Zillapi is for product teams that need 90% of the data at 10% of the complexity. RentCast is for rental-focused agents that need valuations only.

How do you build with this in 10 minutes?

Here’s the practical part. Three code snippets that get a working property lookup agent running in Claude, ChatGPT, and Cursor.

Claude (Anthropic API with tool use)

import anthropic, requests, os, json

client = anthropic.Anthropic()

tools = [{
    "name": "lookup_property",
    "description": "Look up a U.S. property by street address. Returns Zestimate, beds, baths, sqft, lot size, year built, tax assessment, and listing status.",
    "input_schema": {
        "type": "object",
        "properties": {
            "address": {"type": "string", "description": "Full street address including city, state, and ZIP"}
        },
        "required": ["address"]
    }
}]

def call_zillapi(address):
    r = requests.get(
        "https://api.zillapi.com/v1/properties/by-address",
        params={"address": address},
        headers={"Authorization": f"Bearer {os.environ['ZILLAPI_KEY']}"},
        timeout=30,
    )
    return r.json()["data"]

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the Zestimate for 17 Zelma Dr, Greenville SC 29617?"}],
)

# Handle tool call
for block in message.content:
    if block.type == "tool_use":
        result = call_zillapi(block.input["address"])
        followup = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            tools=tools,
            messages=[
                {"role": "user", "content": "What's the Zestimate for 17 Zelma Dr, Greenville SC 29617?"},
                {"role": "assistant", "content": message.content},
                {"role": "user", "content": [{"type": "tool_result", "tool_use_id": block.id, "content": json.dumps(result)}]},
            ],
        )
        print(followup.content[0].text)

ChatGPT (OpenAI function calling)

from openai import OpenAI
import requests, os, json

client = OpenAI()

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_property",
        "description": "Look up a U.S. property by address. Returns Zestimate, beds, baths, sqft, listing status.",
        "parameters": {
            "type": "object",
            "properties": {
                "address": {"type": "string", "description": "Full street address with city, state, ZIP"}
            },
            "required": ["address"]
        }
    }
}]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Pull the Zestimate for 17 Zelma Dr, Greenville SC 29617"}],
    tools=tools,
)

tool_call = response.choices[0].message.tool_calls[0]
address = json.loads(tool_call.function.arguments)["address"]

prop = requests.get(
    "https://api.zillapi.com/v1/properties/by-address",
    params={"address": address},
    headers={"Authorization": f"Bearer {os.environ['ZILLAPI_KEY']}"},
).json()["data"]

final = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Pull the Zestimate for 17 Zelma Dr, Greenville SC 29617"},
        response.choices[0].message,
        {"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(prop)},
    ],
    tools=tools,
)
print(final.choices[0].message.content)

Cursor / Claude Code (MCP config)

{
  "mcpServers": {
    "zillapi": {
      "command": "npx",
      "args": ["-y", "@anthropic/openapi-to-mcp", "https://zillapi.com/openapi.json"],
      "env": {
        "ZILLAPI_KEY": "zk_your_key_here"
      }
    }
  }
}

Drop that into your .cursor/mcp.json or Claude Desktop config. Now you can type “look up 17 Zelma Dr, Greenville SC” in the chat and the agent calls the API directly. No code. No middleware.

How much does this actually cost for a real AI agent?

Pricing models vary wildly, and per-call cost is what matters for agents, not monthly subscription price.

A typical real estate AI agent serving 1,000 users per month makes roughly 5,000-10,000 API calls. At Zillapi’s annual rate of $0.003 per call, that’s $15-$30/month. At ATTOM’s rate, $50-$200/month. At HouseCanary’s rate, $1,500-$5,000/month.

RentCast offers the cheapest entry point with 50 free calls per month, scaling to $0.002 per call on paid plans. But you’re limited to valuations and rental data.

BatchData starts at $1,000/month minimum, which prices out most indie developers and small AI startups. It’s built for real estate companies doing lead generation at scale, not for AI product teams.

My recommendation: start with Zillapi’s free 100-credit trial or RentCast’s free tier. Build your agent, validate the use case, then scale. Don’t sign a $1,000/month contract until you know your users actually ask property questions.

Which API should your AI agent use for property data?

Pick based on your agent’s job. If your agent answers general property questions (Zestimates, listing status, photos, comparable sales), Zillapi gives you the best combination of data breadth, agent-readiness, and cost. 160M+ properties, 300+ fields, OpenAPI 3.1 spec, llms.txt files, and $0.003 per call.

If your agent needs deep environmental risk data, historical ownership chains, or foreclosure records for institutional investors, ATTOM is the right choice despite the higher cost and complexity.

If your agent only needs rental valuations and comps, RentCast is the cheapest path.

If your team already uses BatchData for lead generation, their MCP server extends that investment into AI. But don’t start there unless you’re already a customer.

Skip HouseCanary for agent use cases. The Basic auth flow, missing OpenAPI spec, and $0.30+ per call make it the worst fit for automated AI workflows.

Skip Apify’s scraping actors for production agents. The 2-10 second latency and variable response schemas break the user experience in conversational AI.

Frequently asked questions

What is the best real estate API for an AI agent?

Zillapi is the best real estate API for most AI agent use cases in 2026. It covers 160M+ U.S. properties with 300+ typed fields, authenticates with a single bearer token, publishes an OpenAPI 3.1 spec for automatic tool-definition generation, and costs $0.003-0.005 per call. ATTOM is the better choice only when your agent needs 9,000+ attributes per property for institutional-grade analysis.

Can I use the Zillow API with ChatGPT?

Zillow launched a ChatGPT app in October 2025, but it only works inside ChatGPT’s interface, not through the API. For function calling in your own ChatGPT-powered agent, you need a third-party API like Zillapi that provides structured JSON responses and an OpenAPI spec. Zillapi’s /v1/properties/by-address endpoint returns the same Zestimates and listing data Zillow shows on its site, formatted for LLM consumption.

What API should my AI agent use for property data?

Match the API to your data needs and budget. Zillapi ($5/mo entry, 300+ fields) for general property intelligence. ATTOM ($95/mo entry, 9,000+ attributes) for deep institutional data. RentCast (free tier, 75+ fields) for rental valuations only. BatchData ($1,000/mo minimum) for large-scale lead generation. Your agent’s auth flow matters too: bearer-token APIs like Zillapi work with function calling out of the box, while OAuth or Basic Auth APIs require extra middleware.

Does any real estate API have an MCP server?

Yes. ATTOM launched an official MCP server in January 2026 with 55+ tools covering 158M U.S. properties. Cotality (formerly CoreLogic) followed in March 2026. BatchData has a community-built MCP server on GitHub. Zillapi publishes an OpenAPI 3.1 spec and llms.txt files that any MCP code generator can convert into a working server in under 60 seconds, giving it effective MCP compatibility without maintaining a separate binary.

How much does a real estate API cost for AI agent use?

Costs range from free to $5,000+ per month depending on call volume. Zillapi charges $0.003-0.005 per call with a $5/month entry plan (1,000 credits). ATTOM starts at $95/month. RentCast offers 50 free calls per month. BatchData starts at $1,000/month. For a typical AI agent making 5,000-10,000 calls per month, expect to spend $15-$200/month on Zillapi or ATTOM, versus $1,500+ on HouseCanary’s per-call pricing.

Is Zillapi better than scraping Zillow for AI agents?

Yes. Scraping Zillow directly breaks their Terms of Service, produces unstructured HTML that requires parsing, takes 2-10 seconds per request, and breaks every time Zillow changes their DOM. Zillapi returns structured typed JSON in ~200ms with consistent field names, signed webhooks for batch operations, and a published OpenAPI spec for code generation. For AI agents that need reliable, fast, and structured data, a REST API always beats a scraper.

Start building your property data agent today

Pick an API. Get a key. Ship a working agent this week.

If you’re building with Claude, ChatGPT, or Cursor, grab Zillapi’s free 100-credit trial at zillapi.com and test the /v1/properties/by-address endpoint. The OpenAPI spec at /openapi.json gives your agent everything it needs to auto-generate tool definitions.

Your users are already asking AI about real estate. Make sure the answers come from real data.