How We Handle 30M+ API Requests a Month with ReqKey

On October 2, 2026, RealtyAPI served 1,993,153 API calls in a single day. Every one of them went through ReqKey before we fetched a byte of property data: check the key, charge the credits, log the call. We didn't build the system that did that, and that is the point of this post.

Over the 30 days ending October 23, 2026, ReqKey logged 31.1 million API calls across our real estate APIs. Here is how we handle 30M+ API requests a month with ReqKey, what it takes off our plate, and why it lets a small team ship new APIs to production fast.

30 days of RealtyAPI traffic, by the numbers

Metric	30 days to Oct 23, 2026
API calls logged	31.1 million
Key validations	33.6 million
Busiest day	1,993,153 calls (Oct 2)
Average day	About 1 million calls
Key validation time, p95	Under 5 ms (on ReqKey's side)
Server errors from ReqKey	4, out of roughly 66 million calls we made to it

That last row is the one we like most. A key layer sits in front of every single request, so if it wobbles, everything wobbles. Four server errors in a month of traffic at this volume is the kind of boring we pay for.

Why we didn't build the key layer ourselves

Every API business ends up building a second product: the one that decides who is allowed to call the first one. It starts as a table of API keys. Then it needs per-customer limits, monthly refills, overage, a way to switch off one leaked key, request logs for support, and an audit trail for when someone asks "who changed my limit?"

Each of those is a day to prototype and a quarter to get right. Rolling your own metering layer is a weekend project that keeps shipping for a year.

Our actual product is property data from sources like Redfin, Realtor.com, Rightmove and Idealista. Every hour spent on the toll booth is an hour not spent on the data. So the toll booth is ReqKey's API key management, and our engineering time goes into real estate.

The life of one API request

1. A request arrives with the customer's API key.
2. ReqKey validates it: is the key real, is it active, does the account have credits left? If yes, the credits are charged in the same step.
3. We fetch the data the customer asked for.
4. The response goes back with the remaining balance in the headers, so customers always know where they stand.
5. The call is logged in ReqKey, with its status and timing, ready for analytics and support.

Out-of-credit requests stop at step 2. No wasted upstream work, no free data, and nobody on our team has to notice or step in.

What ReqKey handles for us

Consumers and credits

Every RealtyAPI account is a consumer in ReqKey, with one credit pool shared by all of its keys and every API we offer. That single design choice matters more than it sounds: when we launch a new API, existing customers can call it with the keys they already have, and usage comes out of the same balance. Monthly refills, overage on paid plans and different prices for heavier endpoints are all settings, not code we maintain. The details are on ReqKey's plans and credits page.

Key status: the off switch

The most important feature of an API key system is how fast you can turn something off. ReqKey lets us disable a single key (say, one a customer accidentally made public) without touching their other keys, or pause a whole account at once. Either change applies on the next request, and turning it back on is just as quick.

Rate limits

RealtyAPI plans come with unlimited concurrent requests, because our customers run big batch jobs and that is the point. ReqKey still gives us per-customer rate limits as a lever if we ever need one, and it keeps "out of credits" and "slow down" as two different signals. That distinction matters to anyone writing a client: one means upgrade, the other means retry later.

Request logs

Every call is searchable by customer, endpoint, status code and time. When a customer writes in with "my requests are failing," we look at their actual traffic instead of guessing, and most tickets get answered in one reply. See ReqKey's API traffic view.

Audit logs

Request logs answer "what happened to this call." Audit logs answer "what happened to this account." Every change to keys, customers, plans and credits is recorded with who made it and when, so "why did my limit change?" has a clear answer instead of a guess.

Shipping new APIs to production faster

This is the part that changed our pace the most. Launching a new RealtyAPI provider used to come with a list of key-layer questions. Now it is three steps:

1. Register the new API in ReqKey.
2. Add ReqKey's middleware to it.
3. Deploy.

Keys, credits, logs, analytics and audit history work from the first request. We now run more than 30 real estate APIs this way, from Redfin to international portals, and the key layer hasn't been the slow step in any of those launches.

If you are building your own API, the setup really is small. With the ReqKey Python SDK, a FastAPI app gets key checks, credits and logging from one middleware:

from fastapi import FastAPI
from reqkey.fastapi import ReqKeyMiddleware

app = FastAPI()
app.add_middleware(
    ReqKeyMiddleware,
    project_key="YOUR_REQKEY_PROJECT_KEY",
    api_id="YOUR_API_ID",
    mode="both",  # validate keys AND record analytics
)

There are SDKs for Node, Go, Rust, PHP, .NET and Java as well, and the how it works page walks through the whole loop.

Key takeaways

• Your key layer is a product, not a weekend task. Limits, refills, overage, logs and audit trails add up fast. Buy it unless it is your core business.
• Put credits on the customer, not the key. One pool per account is what lets a new API launch without touching billing.
• Stop unpaid requests before they cost you anything. Checking credits first means no upstream work for calls that won't be paid for.
• Make the off switch fast. You will need to kill a leaked key at a bad hour eventually.
• Keep every call searchable. Real traffic data turns support tickets from guesswork into one reply.

If the key layer is still on your to-do list, ReqKey is what runs ours, and its free tier covers 5 million requests a month, enough to run real production traffic before you pay. And if you are here for property data, everything above is why one RealtyAPI key works across every API we ship: start on the free plan.