Build an ATTOM Property Intelligence MCP Server for Real Estate AI Agents in 2026

Why Real Estate Needs MCP

Real estate analysis requires combining property records, tax assessments, market trends, and neighborhood data across multiple data sources. ATTOM Data covers 150M+ properties with 30+ data layers, but accessing this data programmatically requires API integrations for each endpoint. This MCP server exposes all ATTOM capabilities as agent-callable tools, enabling AI agents to autonomously screen properties, analyze markets, and generate investment reports.

Server Implementation (src/attom-mcp.ts)

// src/attom-mcp.ts
import { FastMCP } from 'fastmcp';
import { z } from 'zod';
import httpx from 'undici';
import Redis from 'ioredis';

const server = new FastMCP({ name: 'attom-property-intelligence', version: '1.0.0' });
const redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379');
const ATTOM_KEY = process.env.ATTOM_API_KEY;
const BASE_URL = 'https://api.gateway.attomdata.com/propertyapi/v1.0.0';

// Tool 1: Property Search
server.tool(
  'search_properties',
  'Search properties by address, city, state, or coordinates',
  {
    address: z.string().optional(),
    city: z.string().optional(),
    state: z.string().optional(),
    zip: z.string().optional(),
    lat: z.number().optional(),
    lng: z.number().optional(),
    radius_miles: z.number().optional().default(1),
    property_type: z.enum(['residential', 'commercial', 'land', 'all']).default('all'),
    max_results: z.number().optional().default(25),
  },
  async (params) => {
    const cacheKey = `attom:search:${JSON.stringify(params)}`;
    const cached = await redis.get(cacheKey);
    if (cached) return { content: [{ type: 'text', text: cached }] };

    const queryParams = new URLSearchParams();
    if (params.address) queryParams.set('address1', params.address);
    if (params.city) queryParams.set('city', params.city);
    if (params.state) queryParams.set('statecode', params.state);
    if (params.zip) queryParams.set('postalcode', params.zip);
    if (params.lat && params.lng) {
      queryParams.set('lat', String(params.lat));
      queryParams.set('lon', String(params.lng));
      queryParams.set('radius', String(params.radius_miles));
    }
    queryParams.set('pagesize', String(params.max_results));

    const resp = await httpx.fetch(
      `${BASE_URL}/property/detail?${queryParams}`,
      { headers: { 'apikey': ATTOM_KEY, 'Accept': 'application/json' } }
    );
    const data = await resp.json();

    const results = data.property?.slice(0, params.max_results).map((p: any) => ({
      address: p.address?.oneLine,
      city: p.address?.city,
      state: p.address?.state,
      zip: p.address?.postal1,
      property_type: p.summary?.proptype,
      year_built: p.summary?.yearbuilt,
      lot_size: p.lot?.lotsize1,
      building_size: p.building?.size?.livingsize,
      beds: p.building?.rooms?.beds,
      baths: p.building?.rooms?.baths,
      assessed_value: p.assessed?.assessedtotal,
      market_value: p.assessed?.mkttotal,
      last_sale_date: p.sale?.saledate,
      last_sale_price: p.sale?.saleprice,
    })) || [];

    const result = JSON.stringify({ results, count: results.length }, null, 2);
    await redis.setex(cacheKey, 3600, result);
    return { content: [{ type: 'text', text: result }] };
  }
);

// Tool 2: Property Valuation Analysis
server.tool(
  'analyze_valuation',
  'Get detailed valuation analysis for a specific property',
  {
    attom_id: z.string().describe('ATTOM property ID'),
  },
  async ({ attom_id }) => {
    const resp = await httpx.fetch(
      `${BASE_URL}/property/detail?attomid=${attom_id}`,
      { headers: { 'apikey': ATTOM_KEY } }
    );
    const data = await resp.json();
    const prop = data.property?.[0];
    if (!prop) return { content: [{ type: 'text', text: 'Property not found' }] };

    const analysis = {
      address: prop.address?.oneLine,
      assessed_value: prop.assessed?.assessedtotal,
      market_value: prop.assessed?.mkttotal,
      tax_annual: prop.tax?.taxamt,
      tax_rate: prop.tax?.taxrate,
      price_per_sqft: prop.assessed?.mkttotal / (prop.building?.size?.livingsize || 1),
      year_built: prop.summary?.yearbuilt,
      building_condition: prop.building?.condition,
      last_sale: { date: prop.sale?.saledate, price: prop.sale?.saleprice },
      valuation_trend: prop.assessment?.year ? 'increasing' : 'stable',
    };

    return { content: [{ type: 'text', text: JSON.stringify(analysis, null, 2) }] };
  }
);

// Tool 3: Neighborhood Scoring
server.tool(
  'neighborhood_score',
  'Get neighborhood quality scores and demographics',
  {
    lat: z.number(),
    lng: z.number(),
    radius_miles: z.number().optional().default(0.5),
  },
  async ({ lat, lng, radius_miles }) => {
    const resp = await httpx.fetch(
      `${BASE_URL}/property/detail?lat=${lat}&lon=${lng}&radius=${radius_miles}&pagesize=50`,
      { headers: { 'apikey': ATTOM_KEY } }
    );
    const data = await resp.json();
    const properties = data.property || [];

    const avgValue = properties.reduce((sum: number, p: any) =>
      sum + (p.assessed?.mkttotal || 0), 0) / properties.length;
    const avgAge = properties.reduce((sum: number, p: any) =>
      sum + (2026 - (p.summary?.yearbuilt || 2026)), 0) / properties.length;

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          center: { lat, lng },
          properties_in_area: properties.length,
          avg_market_value: Math.round(avgValue),
          avg_property_age: Math.round(avgAge),
          property_mix: {
            residential: properties.filter((p: any) => p.summary?.proptype?.includes('RESIDENTIAL')).length,
            commercial: properties.filter((p: any) => p.summary?.proptype?.includes('COMMERCIAL')).length,
          },
          avg_lot_size: Math.round(properties.reduce((s: number, p: any) => s + (p.lot?.lotsize1 || 0), 0) / properties.length),
        }, null, 2)
      }]
    };
  }
);

server.start({ transport: 'stdio' });

Performance Benchmarks

Production Reality Check

Rate-limit handling: ATTOM allows 10,000 API calls/month on the free tier and 100,000/month on paid plans. Cache aggressively: property data changes infrequently. Use Redis with 1-6 hour TTLs. Memory management: ATTOM responses are large (5-10KB per property). For batch analysis of 100+ properties, process in chunks of 25. Failure recovery: If ATTOM returns 429 (rate limited), queue the request and retry after 60 seconds. Never retry immediately.

By <a href="https://x.com/deeepakbagada" rel="nofollow noopener noreferrer">Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with FastMCP 3.14, ATTOM Data API v1.0.0, Node v22, and Redis 7.4.

Related Architecture & Implementation Resources

• Browse complementary servers and client connectors in the Daily AI World MCP Directory.
• Integrate this tool into multi-agent pipelines with our AI Workflows Blueprints.
• Review frontier LLM capabilities and token metrics on Latest AI News.