RentCast vs. PropertiesAPI: Rental Analytics or Zillow Property Data?

Read this with our interest in mind

PropertiesAPI wrote this comparison and sells one of the two services in it. We have tried to describe RentCast from its own public pages and documentation, linked below, and to say plainly where RentCast does things we do not. Capabilities and prices change, so treat this as a dated snapshot and check both vendors' current pages before deciding.

The short version: the two services answer different questions. RentCast is a property data and rental analytics API with its own estimates, listing search and market statistics. PropertiesAPI looks up a property you already know and returns what its public Zillow page shows. Many teams that search for one of these are really looking for the other kind of service.

What RentCast offers, from its own pages

RentCast describes a property data API covering residential and commercial properties across the United States. Its property records include structural attributes, tax assessments, property tax amounts, sale history and current owner details. Its documentation says data is combined from public county records, recorded deeds, tax assessor databases and online feeds.

RentCast produces its own automated valuations: a value estimate and a long-term rent estimate for a specific property, each with a range and a set of comparable listings used to support it. It also offers search across for-sale and for-rent listings and market statistics such as price and rent trends by ZIP code.

Pricing on its API page starts with a free developer tier with a small monthly request allowance, followed by monthly plans priced by request volume and an enterprise option. The billable unit is the API request. Check its pricing page for current allowances and overage rates.

• Compare data categories before choosing any vendor

What PropertiesAPI offers

PropertiesAPI takes a Zillow link, a zpid or a US address and returns the property as JSON: listing price and status, Zillow's Zestimate and rent Zestimate when Zillow shows them, beds, baths, living area, price history, tax history, schools, photo URLs, and the listing agent and broker as shown. A batch endpoint accepts a list of links or addresses in one request.

It does not search for listings, discover comparable properties, supply owner records, or produce estimates of its own. The calculated block in each response is plain arithmetic on the returned fields, such as price per square foot and gross yield from the rent Zestimate, not a valuation model. Data is shown as collected from the public page, as-is, and is not licensed or official Zillow data.

Billing counts successful live lookups. Failed lookups cost nothing, and a repeat lookup of the same home inside the cache window is served from cache without a credit. Plans and the free trial allowance are on the pricing page.

• PropertiesAPI plans and credit rules
• Every field in the property response

Compare by task, not by feature count

Start from the job your application has to do. The table reflects each vendor's public documentation on the date of this article; it is a fit guide, not a quality ranking, and neither column claims accuracy for any estimate.

Run both on your own addresses

The fastest way to decide is to run a short list of your real addresses through both services and look at the results side by side. The script below does that. It records Zillow's rent Zestimate and asking rent from PropertiesAPI, and RentCast's long-term rent estimate, range and number of comparables, using the endpoint and header names from RentCast's API reference.

Read the output for fit, not for a winner. Note which rows each service could answer, whether the property identity matches what you intended, and whether the type of number returned is the one your product needs. An estimate from one model and an estimate shown on a listing page are different things; neither is a completed lease.

Both services bill for requests, under different rules, so use a short list and check each vendor's current terms first. The script stores errors as status codes so failed rows stay visible.

Look closely at rows where only one service answered. A property RentCast can estimate may have no Zillow page the lookup can resolve, and a Zillow listing may describe a unit that a records-based service treats as part of a larger parcel. Those rows usually tell you more about fit than the rows where both returned a number.

"""compare_rent_sources.py: run your own addresses through both services, side by side.

Reads addresses.txt (one address per line). Needs PROPERTIESAPI_KEY and RENTCAST_KEY.
Writes rent_comparison.csv. Both services bill for requests; start with a short list.
"""
import csv
import os
import sys

import requests

PA_URL = "https://api.propertiesapi.com/v1/zillow/property"
RC_URL = "https://api.rentcast.io/v1/avm/rent/long-term"  # per RentCast's API reference


def propertiesapi(session, address):
    response = session.get(PA_URL, params={"address": address},
                           headers={"x-api-key": os.environ["PROPERTIESAPI_KEY"]},
                           timeout=(10, 140), allow_redirects=False)
    if response.status_code != 200:
        return {"pa_error": response.status_code}
    body = response.json()
    data, meta = body["data"], body["meta"]
    return {
        "pa_address": data["address"],
        "pa_status": data["homeStatus"],
        "pa_asking_rent": data["price"] if data["homeStatus"] == "FOR_RENT" else None,
        "pa_rent_zestimate": data["rentZestimate"],
        "pa_fetched_at": meta["fetched_at"],
        "pa_warning": meta.get("warning"),
    }


def rentcast(session, address):
    response = session.get(RC_URL, params={"address": address},
                           headers={"X-Api-Key": os.environ["RENTCAST_KEY"]},
                           timeout=(10, 60), allow_redirects=False)
    if response.status_code != 200:
        return {"rc_error": response.status_code}
    estimate = response.json()
    return {
        "rc_rent": estimate.get("rent"),
        "rc_low": estimate.get("rentRangeLow"),
        "rc_high": estimate.get("rentRangeHigh"),
        "rc_comparables": len(estimate.get("comparables") or []),
    }


def main(path="addresses.txt"):
    columns = ["input", "pa_address", "pa_status", "pa_asking_rent", "pa_rent_zestimate",
               "pa_fetched_at", "pa_warning", "pa_error", "rc_rent", "rc_low", "rc_high",
               "rc_comparables", "rc_error"]
    session = requests.Session()
    with open("rent_comparison.csv", "w", newline="", encoding="utf-8") as out:
        writer = csv.DictWriter(out, fieldnames=columns)
        writer.writeheader()
        for address in filter(None, (line.strip() for line in open(path, encoding="utf-8"))):
            row = {"input": address, **propertiesapi(session, address), **rentcast(session, address)}
            writer.writerow(row)


if __name__ == "__main__":
    main(*sys.argv[1:])

When RentCast is the better fit

Choose RentCast, or another service built for this job, when you need any of the following. In these cases PropertiesAPI is not a substitute.

• A rent or value estimate produced by a model, with a range and comparables.
• Searching for listings that match criteria in an area.
• Owner and parcel-level public record details.
• Market statistics across a ZIP code or city.

When PropertiesAPI is the better fit

Choose PropertiesAPI when your users already have the property, often as a Zillow link, and want what that page shows in a structured form: the listing's status and price, Zillow's estimates when shown, photos, history and agent details. Spreadsheet enrichment, AI agents that look at a specific listing, and tools that compare a shortlist are typical uses.

Some teams use both: an analytics provider for estimates and market context, and a lookup for the specific Zillow listing a user is considering. If you combine them, keep the source on every value so nobody mistakes one model's estimate for another's, and check that both services' terms allow the combination.

• Compare asking rent with rent estimates
• Make your first PropertiesAPI lookup