Restaurant openings API in Python: a 5-minute quick start

You can’t ask Yelp for a restaurant that doesn’t exist yet. It returns nothing, because there’s nothing to return.

But the restaurant does exist on paper. It filed for a liquor license and a food permit weeks ago.

A restaurant openings API returns restaurants and bars before they open, built from public liquor-license applications, food permits and business filings instead of review listings.

With Python and the requests library, you can pull scored, upcoming venues for a state in about 30 lines. I ran every call in this guide against the live API on October 17, 2026, and the output you’ll see is real.

I built RestoSignals, so this is my API. I’ll show you exactly what it returns, what it costs, and where it falls short.

What is a restaurant openings API?

A restaurant openings API is a web API that returns restaurants and bars that haven’t opened yet. Instead of reading review listings, it reads the public paperwork a new venue files during buildout: liquor-license applications, new food permits and new business registrations. It merges those into one record per venue and scores how close each one is to opening, so your code gets a ranked list instead of raw filings.

Yelp and Google Places describe places people can walk into today. A restaurant openings API describes places people will be able to walk into in a month or three.

Here’s what each one actually sees.

Why does the timing matter? If you sell to restaurants, the buying happens early.

In a 2025 survey of 220 operators, 71% said they start choosing vendors more than 90 days before opening, according to Restaurant Technology News.

By the time a venue shows up on Yelp, most of those decisions are made.

Can the Yelp or Google Places API find restaurants before they open?

The Yelp API and the Google Places API can’t reliably find restaurants before they open, because both only return places that already have a public listing. A new restaurant typically gets that listing around opening day. To see it earlier, you need the filings it makes during buildout, which appear in state and city records weeks or months before the doors open.

I’m not knocking either API. They’re great at their job.

If you want ratings, reviews, hours and photos for restaurants that exist, use them. Google’s coverage is huge, and Yelp’s review data is deep.

But they answer a different question.

“What’s on this block?” is a listings question. “What’s about to open on this block?” is a filings question.

Most apps that care about new restaurants end up needing both: filings to find a venue early, and listings later, once it’s open, to enrich it.

	Yelp API	Google Places API	Restaurant openings API
Built from	Public listings and reviews	Google Maps places	Liquor, permit and business filings
Finds a venue	Once it’s listed, around opening	Once it’s on Maps	During buildout, before opening
Best for	Ratings and reviews	Coverage, hours, photos	Timing and new leads
Owner details	No	No	Owner name from the filing (paid plan)
Pricing model	Paid API plans	Pay per request, by SKU	Per lead returned, empty results free

How do you get restaurant openings data in Python?

To get restaurant openings data in Python, get a free API key, install requests, and call GET /v1/openings with a state and a small limit. The API returns JSON with scored venues, the filings behind each one, and your remaining credits. Six steps take you from nothing to a CSV of upcoming restaurants, and the code is about 30 lines.

Step 1: get a free API key

Sign up at restosignals.com/signup for 100 free lead credits, with no card. Your key is in the dashboard under Keys, with a Copy button.

Keep it out of your code. Put it in an environment variable:

export RESTOSIGNALS_KEY="pk_your_key_here"

On Windows PowerShell, that’s $env:RESTOSIGNALS_KEY = "pk_your_key_here".

Step 2: install requests and check your balance

I ran this on Python 3.12, and any recent Python 3 should work. Install the only dependency:

pip install requests

Then confirm the key works. The account call is free:

import os
import requests

API = "https://api.restosignals.com"
s = requests.Session()
s.headers.update({"X-API-Key": os.environ["RESTOSIGNALS_KEY"]})

r = s.get(f"{API}/v1/account", timeout=30)
print(r.status_code, r.json()["plan"], r.json()["credits"])

When I ran it with a trial key, it printed 200 free 15. A new account from the sign-up page starts at 100 credits.

Step 3: make your first call

Ask for the strongest leads in one state, and keep the limit small while you test:

r = s.get(f"{API}/v1/openings",
          params={"state": "IL", "min_opening_score": 80, "limit": 3},
          timeout=30)
data = r.json()
for o in data["openings"]:
    print(o["dba"] or o["business_name"], o["city"], o["opening_score"], o["signal_types"])
print("credits used:", data["credits_used"], "left:", data["credits_remaining"])

That’s the real call. Here’s what it printed, in about 1.2 seconds:

The Reserve CHICAGO 80 ['food_permit', 'liquor']
TAXIM CHICAGO 80 ['food_permit', 'liquor']
LA CATRINA MEXICAN RESTAURANT CHICAGO 80 ['food_permit', 'liquor']
credits used: 3 left: 12

Three Chicago venues, each with both a liquor filing and a food permit, filed on October 16, the day before I ran this.

What does the restaurant openings API return?

Each venue in the response has a business name and DBA, address, city, state and county, coordinates, an opening_score from 0 to 100, the signal types behind it, and the earliest and latest filing dates. The response also reports credits used and remaining. Owner contact details are locked on free keys, but the response tells you whether a contact exists.

Here’s the first venue from that Illinois call, exactly as the API returned it:

{
  "id": 732048,
  "business_name": "Bottleneck Reserve LLC",
  "dba": "The Reserve",
  "address": "500 W MADISON ST 3",
  "city": "CHICAGO", "state": "IL", "county": "Cook",
  "lat": 41.8819943382, "lng": -87.6397586849,
  "opening_score": 80,
  "status": "opening",
  "signal_types": ["food_permit", "liquor"],
  "earliest_signal_date": "2026-10-16",
  "latest_signal_date": "2026-10-16",
  "contact": {"locked": true, "available": true,
              "unlock": "Subscribe to reveal the owner name and contact details."}
}

The field that matters most is opening_score.

A venue backed by one filing scores low.

A venue where two or three independent filings line up at the same address scores high, and 80 or above counts as a hot lead. A three-signal venue (business filing, food permit and liquor) scores 100.

signal_types tells you why. [“food_permit”, “liquor”] means the kitchen is being permitted and alcohol is being licensed, at the same place.

The response headers carry your balance too. That call returned X-Credits-Used: 3 and X-Credits-Remaining: 12, which is handy if you log usage.

How do you filter and page through restaurant openings in Python?

Filter the openings endpoint with state, city, signal_type, min_opening_score and since, and page through results with limit and offset. The default limit is 10, and each returned venue costs one credit, so small pages are cheaper while you test. Results come back highest-scoring first, then newest, so page one is always the strongest set.

Here’s how I paged through New York, three at a time:

def page(state, offset, size=3):
    r = s.get(f"{API}/v1/openings",
              params={"state": state, "min_opening_score": 90, "limit": size, "offset": offset},
              timeout=30)
    return r.json()["openings"]

page1 = page("NY", 0)
page2 = page("NY", 3)

Page one came back with Diner 24 Broadway, Straker’s NYC and Osteria Brooklyn on Jackson, all scored 100 with all three signal types. Page two continued with Medusa Art Studios & Events, Park Buffet and TMK Wagner Park.

The other filters do what you’d expect:

• city="Brooklyn" narrows to one city, case-insensitive.
• signal_type="liquor" keeps only venues with a liquor filing, if you sell to bars.
• since="2026-10-01" keeps venues with a filing on or after that date, which is how you run a “what’s new since last week” job.

There’s also GET /v1/openings/latest for venues with a signal in the last 7 days, and GET /v1/signals for the raw filings if you want to do your own matching.

How do you save restaurant openings to a CSV?

To save restaurant openings to a CSV in Python, loop over the openings list and write one row per venue with the standard csv module. Keep the columns your CRM needs, like business name, city, state, opening_score and signal types. A file like this imports into HubSpot, Salesforce or a Google Sheet as it is.

import csv

rows = page1 + page2
with open("new_openings_ny.csv", "w", newline="", encoding="utf-8") as f:
    w = csv.writer(f)
    w.writerow(["business_name", "city", "state", "opening_score", "signal_types"])
    for o in rows:
        w.writerow([o["business_name"], o["city"], o["state"],
                    o["opening_score"], "|".join(o["signal_types"])])

The first lines of the file it wrote:

business_name,city,state,opening_score,signal_types
DINER 24 BROADWAY NYC LLC.,New York,NY,100,business|food_permit|liquor
Straker's NYC Inc.,New York,NY,100,business|food_permit|liquor
Osteria Brooklyn on Jackson Corp.,Long Island City,NY,100,business|food_permit|liquor

Seven lines: a header and six venues. That’s the whole quick start.

How do API credits work, and what happens when they run out?

You pay one credit per venue returned, not per request. Calls that return nothing are free, and so are the account, usage and webhook-list calls. If you ask for more rows than your balance covers, the API returns what you can afford and sets truncated_by_balance to true. At zero credits, metered calls return HTTP 402, “Out of credits.”

I drained my trial key on purpose to show you.

With 6 credits left, I asked for 10 New York venues.

I got 6 back, with truncated_by_balance: true and 0 credits remaining. The next call returned 402 {"detail": "Out of credits. Top up or upgrade."}.

A wrong key returns 401 {"detail": "Missing or invalid X-API-Key."}.

So the error handling you need is short:

r = s.get(f"{API}/v1/openings", params={"state": "NY", "limit": 10}, timeout=30)
if r.status_code == 401:
    raise SystemExit("Bad API key - check RESTOSIGNALS_KEY")
if r.status_code == 402:
    raise SystemExit("Out of credits - top up at restosignals.com")
r.raise_for_status()
data = r.json()
if data["truncated_by_balance"]:
    print("Got fewer rows than asked; balance ran out")

Keep the timeout=30. Most calls come back in about a second, but you never want a script hanging forever on a network blip.

On pricing: sign-up gives 100 free credits, top-ups are $4 per 1,000 leads or $18 per 5,000, and credits never expire, per the RestoAPI page.

There’s no per-minute rate limit on the data endpoints today. Credits are the limit.

Can you build this from free open data instead?

You can build this from free government open data, and the data itself costs nothing. The work is in the plumbing: finding each state and city dataset, writing a client per portal, normalizing names and addresses, and matching liquor, permit and business rows that refer to the same venue. The common Python client for Socrata portals, sodapy, has been unmaintained since August 2022.

I know, because that’s what I built.

Every state publishes differently.

New York’s liquor data, Chicago’s business licenses and California’s pending ABC applications each have their own fields, formats and quirks. The hard part isn’t downloading them. It’s knowing that an LLC name on a liquor filing and a different trade name on a food permit, at the same address, are the same restaurant.

If you only need one city and you enjoy this kind of work, go for it. Python is the right tool, and most developers already know it: 57.9% of developers used Python in the past year, according to the 2025 Stack Overflow Developer Survey.

Just know what you’re signing up for. The sodapy notice on PyPI says it “still works well, but is unmaintained as of Aug 31, 2022.”

Coverage is the other thing to check before you build on any data source.

RestoSignals covers seven states today: New York, Texas, Illinois, California, Oregon, Colorado and Washington. After today’s refresh, that’s 29,699 scored venues, 509 of them hot leads.

Colorado and Washington have venues but no hot leads yet. If you need Florida or Georgia, this API won’t help you today.

What can you build next with restaurant openings data?

Once the quick start works, the useful next builds are a weekly script that emails your sales team new venues since last Monday, a webhook that pings Slack when a new bar files in your territory, and an AI agent that queries the same data through MCP. Each one reuses the same key and the same credits.

A few starting points:

1. Weekly digest. Run the script on a schedule with since set to seven days ago, and email the CSV.
2. Territory alerts. Register a webhook with POST /v1/webhooks and a criteria object like {"state": "NY", "city": "Brooklyn", "signal_type": "liquor"}. Webhooks need a paid plan or a purchased credit pack.
3. CRM sync. Push each new venue into HubSpot or Salesforce as a lead, keyed on the venue id so you never create duplicates.
4. AI agent. Connect the same data to Claude through MCP. Anthropic counted more than 10,000 active public MCP servers when it donated the protocol in December 2025. I walked through that setup in how to build an AI agent that finds new restaurant leads.

Start with one state and three rows

Your first restaurant openings API call should be one state, a minimum score of 80 and a limit of 3. It costs 3 credits, comes back in about a second, and shows you exactly what the data looks like before you build anything around it. Once that works, page, filter and save to CSV, and you have a pipeline of restaurants before they open.

The full API reference is in the docs. If you’d rather skip code and browse the same leads, the dashboard does that without spending credits.

And if you sell to these venues rather than build with them, read how to sell to new restaurants before they open.

Weighing other data sources? See restaurant API compared: Yelp, Google Places, Foursquare and RestoAPI.

---

Mukul Dutt is the founder of RestoSignals, which tracks restaurants and bars before they open by fusing public liquor, permit and business-filing records into one scored venue, available as a dashboard, a REST API and an MCP server. Every call and output in this guide was run against the live API on October 17, 2026.