Apify is the actor framework underneath Zillapi. We use it. We are not hiding it.
If you want to run Zillow actors yourself with full control of the input schema, retries, and the run lifecycle, pick Apify. If you want a stable Zillow API with one key, one URL, an OpenAPI spec, and a bill that does not depend on compute units you have to model, pick Zillapi.
TL;DR
| Zillapi | Apify | |
|---|---|---|
| Pricing | $5/mo for 1,000 credits, scales to $99+ | Free $5/mo platform credit, then per-CU |
| Free tier | 100 credits one-time at signup | $5/mo recurring platform credit on Free |
| Signup speed | Email, key in under 60 seconds | Email, then console setup, a few minutes |
| Coverage | Zillow listing graph (for-sale, rent, sold, Zestimate) | Same actor pool, you call it directly |
| Output formats | JSON, CSV, NDJSON | JSON, CSV, XML, Excel, JSONL |
| Webhooks | First-class, HMAC-signed | Yes, on actor run finish |
| OpenAPI | /openapi.json covers every endpoint | Per-actor input schema only |
| Best for | Production apps that want one stable API | Teams that want to own actor runs |
What is Apify?
Apify is a marketplace and runtime for web-scraping actors. Each actor is a containerized scraper with its own input schema, pricing, and maintainer. You pay for actor runs plus platform compute units, where 1 CU is 1 GB of RAM running for 1 hour, per the Apify pricing page.
The Free plan ships with $5 in monthly platform credit. Paid plans start at the $1/mo Creator plan and scale into Starter, Scale, and Business tiers with bigger CU bundles and lower per-CU rates. Apify SDKs ship in JavaScript and Python, and the platform handles proxy rotation, run scheduling, dataset storage, and retry policies.
For Zillow specifically, the most-used actors are maxcopell/zillow-detail-scraper, maxcopell/zillow-scraper, and maxcopell/zillow-zip-search. They are well maintained. Apify’s runtime is solid.
The catch is that you are still operating actor runs. Not consuming a versioned API.
What is Zillapi?
Zillapi is a productized Zillow Data API. One API key. One base URL. Predictable per-credit pricing.
Endpoints like /v1/properties/{zpid} and /v1/listings/for-sale return clean JSON with stable field names. Sub-resources like /photos, /zestimate, and /price-history let you fetch the slice you need without parsing a five-megabyte blob.
We are upfront about how this works. Zillapi calls the same maxcopell/zillow-detail-scraper and zillow-scraper actors that power many Apify users’ Zillow pipelines. We pay for the compute. We run the cache. We take the on-call burden. We sell the result as a clean REST API.
Side-by-side: making the same call
Same task, both providers. Fetch one Zillow property by zpid.
Zillapi:
curl https://api.zillapi.com/v1/properties/11026031 \ -H "Authorization: Bearer $ZILLAPI_KEY"Returns the cached property record in 50 to 200 ms. Costs 1 credit. Falls back to a fresh upstream fetch if the cache is cold.
Apify, calling the underlying actor with run-sync-get-dataset-items:
curl -X POST \ "https://api.apify.com/v2/acts/maxcopell~zillow-detail-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \ -H "content-type: application/json" \ -d '{"propertyUrls":["https://www.zillow.com/homedetails/11026031_zpid/"]}'You get the run output as a dataset. You manage the input shape, the run lifecycle, and any caching you build on top.
The Apify call is fine. It is also a different mental model. You are running a job, not querying an API.
Pricing breakdown
Apify, per public pricing as of May 2026:
- Free plan: $5/mo platform credit, no card required.
- Creator plan: $1/mo, $500 of platform usage in the first 6 months.
- Starter, Scale, Business: progressively bigger CU bundles, with effective per-CU rates dropping as you scale.
- The maxcopell/zillow-detail-scraper actor lists at $3 per 1,000 results per its Apify Store page.
Your real cost on Apify is actor cost + platform CU cost + proxy cost. For most Zillow workloads, the per-result actor charge dominates, but you still need to model CU usage to avoid surprises.
Zillapi, per public pricing on / as of May 2026:
- Free at signup: 100 credits.
- Hacker: $5/mo, 1,000 credits.
- Pro: $29/mo, 10,000 credits.
- Scale: $99/mo, 50,000 credits.
- Most endpoints cost 1 credit. Heavy listing pages and async jobs cost more, documented per endpoint in
/openapi.json.
The wrapper is not free. You are paying us to absorb the actor changelog, run a hot cache, and ship a stable v1 schema. If your volume is high enough that running actors directly costs less, the math at some point flips.
When to choose Apify
Pick Apify if you want full control of the scraper. If you plan to run dozens of different actors across many sources, the platform earns its keep. If you have engineers who already live in Apify Console, adding another vendor on top buys you very little.
Apify is also the right call if you want to fork the actor and patch it yourself. Zillow ships layout changes. Sometimes a selector breaks for an edge case you care about and the upstream actor takes a day to ship a fix. Owning the actor source means you can patch and redeploy on your own clock.
If your volume is high enough that paying per credit on a wrapper costs more than running actors directly, Apify wins on raw economics.
When to choose Zillapi
Pick Zillapi when you want a Zillow API that behaves like Stripe or Twilio.
One key. One URL. An OpenAPI 3.1 spec. Real webhooks with HMAC signatures. Real rate limits with backoff headers. Real billing.
We absorb the actor upgrades when Zillow ships a DOM change. We run a 24-hour cache by zpid so repeat lookups cost nothing. Sub-resource endpoints mean you do not pay to parse a giant blob when you only need photos or only need the Zestimate.
For teams shipping a feature, Zillapi is faster to integrate. We measure first-call time in seconds, not afternoons.
The honest case against Zillapi
Zillapi is a wrapper. The unit economics will not always favor us.
If your volume crosses a threshold where running actors directly is materially cheaper, even after you account for engineering time, you should leave. We will not pretend otherwise. Wrappers earn their keep on the long tail of small and mid-size projects. At very high volume, going to the source is the rational call.
We also do not let you customize the scraper. If you need a field the upstream actor does not expose, or you want a different parser pass, that is not us. Run the actor yourself.
And we are a single source. Zillapi covers Zillow. If your roadmap needs Realtor.com, Redfin, or MLS feed data alongside Zillow, you are stitching together two or three vendors. Apify lets you run scrapers across all of those from one runtime.
FAQ
Is Zillapi really built on Apify?
Yes. We call the maxcopell/zillow-detail-scraper and related actors as one of our upstream sources. We pay for the compute, run a 24-hour cache, handle billing, expose a stable v1 contract, and absorb actor upgrades when Zillow ships a layout change. We are upfront about it.
If Zillapi runs on Apify actors, why not just use Apify directly?
If you want to own actor runs, manage the input schema, build your own retry and dedup logic, and watch Apify’s actor changelog, run actors directly. If you want a v1 REST contract, sub-resource endpoints, HMAC webhooks, and one bill, use Zillapi. The wrapper is the product.
How much does Apify actually cost?
Apify’s Free plan ships with $5 in monthly platform credit. Paid plans start at $1/mo for the Creator plan and scale up from there. Actor cost is per compute unit, where 1 CU is 1 GB of RAM running for 1 hour. The maxcopell/zillow-detail-scraper actor lists at $3 per 1,000 results per its Apify Store page.
Can I switch from Apify to Zillapi without rewriting everything?
Yes. If your code calls the actor and parses the dataset, the migration is mostly swapping the request and renaming a few fields. Our /v1 schema is stable and documented at /openapi.json. Most teams migrate in a day.
Does Zillapi cache results?
Yes. We cache by zpid for 24 hours by default. Repeat lookups inside that window return in 50 to 200 ms and do not bill against your upstream actor budget. You can force a fresh fetch with a query parameter when you need it.
What if I need fields the underlying actor does not return?
Then Apify direct is the better fit. With Zillapi, you get the fields we expose in /v1. We do not let you patch selectors or add custom parser steps. If you need that, run the actor yourself or fork it on Apify.
Verdict
If you have a team that wants to run actors and own the runtime, Apify is the right call. The platform is good. The actors are good. The economics work at scale.
If you want a Zillow API your backend can call this afternoon, start with the Zillapi quickstart. First call in 60 seconds. No actor lifecycle to manage. One bill. One key. One stable schema.
Zillapi is an independent service and is not affiliated with, endorsed by, or sponsored by Zillow Group, Inc. “Zillow” and “Zestimate” are registered trademarks of Zillow Group, Inc. Use of those marks on this site is descriptive (nominative fair use). Read our full trademark posture.