Real Estate Data Parsing Guide

{
    'address': '123 Main St, Austin, TX 78701',
    'price': 450000,
    'bedrooms': 3,
    'bathrooms': 2.5,
    'sqft': 2100,
    'lot_size': 0.25,  # acres
    'year_built': 1995,
    'property_type': 'Single Family',
    'zestimate': 465000,
    'rent_zestimate': 2500,
    'status': 'active',
    'days_on_market': 15,
    'photos': ['url1', 'url2', ...],
    'coordinates': {'lat': 30.267, 'lng': -97.743}
}

prop = api.platforms.zillow.get_property(address)
 
# Safe access with defaults
bedrooms = prop.bedrooms if prop.bedrooms else 0
price = prop.price if prop.price else 0
 
# Or use getattr with default
sqft = getattr(prop, 'sqft', 0)

from propapis import PropAPIS, APIError
 
api = PropAPIS(api_key='your_api_key')
 
try:
    prop = api.platforms.zillow.get_property(address)
except APIError as e:
    if e.status_code == 404:
        print(f"Property not found: {address}")
    elif e.status_code == 429:
        print("Rate limit exceeded, retrying...")
        time.sleep(60)
    else:
        print(f"API error: {e}")

import time
 
def get_property_with_retry(address, max_retries=3):
    for attempt in range(max_retries):
        try:
            return api.platforms.zillow.get_property(address)
        except APIError as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # 1s, 2s, 4s
                time.sleep(wait_time)
            else:
                raise

def validate_property(prop):
    errors = []
 
    if not prop.price or prop.price <= 0:
        errors.append("Invalid price")
 
    if not prop.bedrooms or prop.bedrooms < 0:
        errors.append("Invalid bedrooms")
 
    if prop.sqft and prop.sqft < 100:
        errors.append("Suspiciously small sqft")
 
    if errors:
        print(f"Validation errors for {prop.address}:")
        for error in errors:
            print(f"  - {error}")
        return False
 
    return True
 
# Use validation
prop = api.platforms.zillow.get_property(address)
if validate_property(prop):
    # Process property
    pass

def clean_property_data(prop):
    cleaned = {
        'address': prop.address.strip(),
        'price': int(prop.price) if prop.price else None,
        'bedrooms': int(prop.bedrooms) if prop.bedrooms else None,
        'bathrooms': float(prop.bathrooms) if prop.bathrooms else None,
        'sqft': int(prop.sqft) if prop.sqft else None,
    }
 
    # Calculate derived fields
    if cleaned['price'] and cleaned['sqft']:
        cleaned['price_per_sqft'] = cleaned['price'] / cleaned['sqft']
 
    return cleaned

def process_properties_batch(addresses):
    results = []
 
    for i, address in enumerate(addresses):
        try:
            prop = api.platforms.zillow.get_property(address)
 
            if validate_property(prop):
                cleaned = clean_property_data(prop)
                results.append(cleaned)
 
            # Progress indicator
            if (i + 1) % 10 == 0:
                print(f"Processed {i + 1}/{len(addresses)}")
 
        except Exception as e:
            print(f"Error processing {address}: {e}")
            continue
 
    return results
 
# Process list
addresses = ['123 Main St, Austin, TX', ...]
results = process_properties_batch(addresses)

from concurrent.futures import ThreadPoolExecutor
 
def fetch_property(address):
    try:
        return api.platforms.zillow.get_property(address)
    except Exception as e:
        print(f"Error: {address} - {e}")
        return None
 
# Process in parallel
addresses = ['addr1', 'addr2', 'addr3', ...]
 
with ThreadPoolExecutor(max_workers=5) as executor:
    properties = list(executor.map(fetch_property, addresses))
 
# Filter out None values
properties = [p for p in properties if p is not None]

import csv
 
def export_to_csv(properties, filename):
    with open(filename, 'w', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=[
            'address', 'price', 'bedrooms', 'bathrooms',
            'sqft', 'zestimate', 'rent_zestimate'
        ])
 
        writer.writeheader()
        for prop in properties:
            writer.writerow({
                'address': prop.address,
                'price': prop.price,
                'bedrooms': prop.bedrooms,
                'bathrooms': prop.bathrooms,
                'sqft': prop.sqft,
                'zestimate': prop.zestimate,
                'rent_zestimate': prop.rent_zestimate
            })
 
# Export
export_to_csv(properties, 'properties.csv')

import json
 
def export_to_json(properties, filename):
    data = [clean_property_data(p) for p in properties]
 
    with open(filename, 'w') as f:
        json.dump(data, f, indent=2)
 
# Export
export_to_json(properties, 'properties.json')

from functools import lru_cache
import hashlib
 
@lru_cache(maxsize=1000)
def get_property_cached(address):
    return api.platforms.zillow.get_property(address)
 
# Use cached version
prop = get_property_cached('123 Main St, Austin, TX')

import time
 
def rate_limited_requests(addresses, requests_per_minute=100):
    delay = 60.0 / requests_per_minute
 
    for address in addresses:
        prop = api.platforms.zillow.get_property(address)
        yield prop
        time.sleep(delay)
 
# Use generator
for prop in rate_limited_requests(addresses):
    process(prop)

from propapis import PropAPIS
 
api = PropAPIS(api_key='your_api_key')
 
# Basic usage with error handling
try:
    prop = api.platforms.zillow.get_property('123 Main St, Austin, TX')
 
    # Validate data
    if prop.price and prop.bedrooms:
        print(f"{prop.address} - ${prop.price:,}")
    else:
        print("Incomplete data")
 
except Exception as e:
    print(f"Error: {e}")