The same steps work in Bolt, v0, Replit or Cursor. Only the “where do I put the secret” step changes.

1. Get a free API key

Create a FindLocal account and make a key on the dashboard. The free plan has no card. Calls per month are on the pricing page.

Keep the key secret. It goes in a server-side secret, never in browser code.

2. Store the key as a secret

In Lovable, connect Supabase (Lovable’s built-in backend) and add a secret named FINDLOCAL_KEY with your key as the value. On other platforms, use the environment-variable or secrets panel for server code.

3. Paste this prompt

Give Lovable this prompt as it is, and change the city if you like:

Add an "Events this week" page.

Create a Supabase Edge Function called `events` that calls
GET https://findlocal.community/api/events?city=austin&when=week&sort=featured
with the header `Authorization: Bearer ${FINDLOCAL_KEY}` (read FINDLOCAL_KEY from
the function's secrets — never expose it to the browser). Accept optional `city`,
`when` and `cat` query params and pass them through. Return the JSON unchanged.
Cache the response for 10 minutes.

On the page, call that function and render `data` as a responsive card grid:
image_url (hide if null), title, event_date + start_time, venue_name, price,
and a button linking to ticket_page_url (fall back to detail_page_url).
Add filter chips for when = today | weekend | week and cat = music | comedy |
trivia | family | literary. Show "Event data by FindLocal" linking to
https://findlocal.community in the page footer.

That’s all of it. Lovable writes the function, the page and the filters.

What the API returns

/api/events returns { data: [...], meta: {...} }. Each event is flat JSON:

{
  "id": "…",
  "title": "Tuesday Trivia",
  "event_date": "2026-10-27",
  "start_time": "19:30",
  "category": "trivia",
  "price": "Free",
  "venue_name": "…",
  "venue_lat": 30.26,
  "venue_lng": -97.74,
  "image_url": "https://…",
  "ticket_page_url": "https://…"
}

Dates and times are in the venue’s own time zone, so you never have to convert them. The full field list and every filter are in the docs, and you can try queries there without a key.

Useful variations

• Near the user: replace city= with near=<lat>,<lng>&radius_km=10 to sort by distance from the browser’s location.
• Only free events: add free=1.
• Search: q=jazz matches titles, venues, performers and descriptions.
• One category: cat=comedy or cat=literary (bookstores and libraries).

Things that commonly go wrong

• The key ends up in the browser. If the AI tool puts the fetch in a React component, ask it to move the call into the Edge Function. Anyone can read a key that ships to the browser.
• Calling on every render. Cache in the function (the prompt asks for 10 minutes). Listings refresh daily, so you don’t need anything fresher.
• Credit line. On the Free plan, keep the “Event data by FindLocal” link visible where the events appear (see the API terms). Paid plans don’t need it.

No backend at all? Use the widget

If you just want events on a page and don’t need your own design, the FindLocal widget is one script tag with no key. It gives you a list, calendar and map with filters, and you can paste it into any site builder that accepts HTML.

Building an agent instead?

The same key works with the FindLocal MCP server, so Claude, Cursor or any MCP client can search events directly.

Today there are four:

All four read the same database, so a bookstore’s widget, a newsletter’s API call and an assistant’s tool result always agree.

The widget

Paste one line where you want the calendar:

<script src="https://findlocal.community/widget.js" data-widget="literary-new-england"></script>

That’s it. The tag inserts a small frame that shows upcoming events three ways — a date-grouped list, a month calendar you can click through, and a map of the venues — with a “Powered by FindLocal” credit at the bottom. It sizes itself to its content, follows your visitor’s light or dark setting, works in a sidebar or full width, and every event links back to its page on Find Local (and from there to the venue’s own listing or ticket page).

There’s no code to maintain and nothing to update. As venues change their calendars and our scrapers pick the changes up, the widget changes with them.

Why Literary New England first

This summer we onboarded nearly three hundred literary venues across New England — independent bookstores, public libraries, writing centers and literary organizations — in eighteen metro areas from Stamford to Bangor, and gave their events their own literary category: author talks, readings, book launches, book clubs, poetry, storytelling, workshops.

It was the obvious first widget for two reasons. First, the audience is real and underserved: the people who go to a Tuesday-night reading at a bookstore in Northampton find out about it from a chalkboard, a newsletter or a friend, not from a ticketing aggregator. Second, these venues are exactly the kind of organizations that should be able to show “what’s happening around here” on their own site without hiring a developer. A library can now put the whole region’s literary calendar on its events page, and a bookstore blog can show what’s on across the state next to its own listings.

“New England” isn’t a thing our database knew about — events belong to one metro partition each. So the widget introduces region groups: named bundles of metros that a widget can query at once. new-england is the first; others are a one-line change, so tell us which you’d like.

Build your own

The preset is one of many combinations. Every widget takes a scope and, optionally, a category, a date window, an initial view and a theme:

<!-- Comedy in Chicago this weekend, map first, dark -->
<script src="https://findlocal.community/widget.js"
  data-city="chicago" data-cat="comedy" data-when="weekend"
  data-view="map" data-theme="dark"></script>

The widget page has a builder that writes the tag for you and shows a live preview, plus the full attribute reference. If you want to see which of your readers click through, add data-partner="your-site" and it rides along on every link as a UTM parameter.

The other doors, briefly

The JSON API is the same data as plain HTTPS: GET https://findlocal.community/api/events?city=boston&when=weekend&cat=music. It needs an API key — there’s a free tier, no card — sent as Authorization: Bearer <key>. CORS open, cached for five minutes at the edge, and every filter the site has is a query parameter. You can run real queries without a key in the playground. Reference · walkthrough.

The MCP server at https://mcp.findlocal.community/mcp gives an assistant nine tools — search events (by performer too), look up a venue, list categories, check usage and so on — so “anything free in Cambridge tonight?” gets a sourced answer with links instead of a confident guess. It uses OAuth plus the same API key as the JSON API, free tier included. Reference · walkthrough.

And if you’re a team evaluating the data rather than a person embedding a calendar, the home page and the comparison are the short version of why it’s different: aggregated across sources, structured, and kept current, with the long tail of venue-site events the big platforms never see.

What’s next

• More presets: per-city “this weekend” widgets, a single-venue widget for venues that want their own calendar on their own site, and category widgets for the parks and outdoors events we added earlier this year.
• More region groups as people ask for them.
• A way for widget partners to see their own referral numbers without emailing us.

If you put a widget somewhere, we’d love to see it — elliot@findlocal.community. And if there’s a door you need that isn’t here yet, say so. The whole point is that the data should be able to go wherever local events are actually discovered.

Reference: the up-to-date endpoint, parameter and field tables now live at /docs. This post is the walkthrough.

Update: the JSON API now requires an API key — send it as an Authorization: Bearer <key> header. There’s a free tier; get a key at /pricing. The embeddable widgets and the map endpoint stay free and keyless.

Every listing page on Find Local has a JSON twin. The same filters you click on the site — city, date, category, price, time of day, neighborhood, performer, search — work as query parameters against https://findlocal.community/api/events, and the response is the same data the page renders. It requires an API key (there’s a free tier, no card — plans and quotas at /pricing), sent as an Authorization: Bearer <key> header, and CORS is open, so you can call it from a browser, a script, a spreadsheet, or a cron job.

If you’d rather have an AI assistant do the querying, see the companion guide on connecting FindLocal to Claude, Cursor, and other assistants over MCP.

Endpoints

Base URL: https://findlocal.community. Only GET (and OPTIONS) are supported.

Quick start

# Live music in Boston this week
curl 'https://findlocal.community/api/events?city=boston&cat=music&when=week&limit=5'

# Free things to do in Brooklyn this weekend, evenings only
curl 'https://findlocal.community/api/events?city=new-york&region=Brooklyn&when=weekend&free=1&tod=evening'

# Every active venue in Chicago
curl 'https://findlocal.community/api/venues?city=chicago'

Filtering /api/events

The parameters mirror the site’s URLs exactly: /city/boston?cat=music&when=weekend on the site is /api/events?city=boston&cat=music&when=weekend on the API.

Unknown values are ignored rather than rejected, so cat=jazz quietly matches nothing extra — check the response meta.total if a filter seems to have no effect.

Response shape

{
  "data": [ /* EventRow[] */ ],
  "meta": { "city": "Boston", "currency": "USD", "count": 5, "total": 82, "page": 1, "page_size": 5, "sort": "date" }
}

total is the full match count for the filters; count is how many rows are in this page; currency is the ISO code every price_amount in the page is in (GBP for London). /api/events?ids=… returns meta: { count } only, and /api/events/<uuid> returns { "data": {…} } or a 404 with { "error": "not found" }.

An event row looks like this (trimmed from a real response):

{
  "id": "8f9b9068-4e11-466b-a1cc-d36230d28fdd",
  "title": "Hooley Hour",
  "description": "donate to artists 5-7pm all ages",
  "event_date": "2026-09-04",
  "start_time": "17:00:00",
  "end_time": null,
  "city": "Boston",
  "region": "Cambridge",
  "category": "music",
  "event_type": ["Theater", "Music"],
  "performers": [{ "name": "The Hooley Band", "role": "headliner" }],
  "price": null,
  "price_amount": null,
  "detail_page_url": "https://www.lilypadinman.com/home/2026/hooley-hour-bs5y2-pl4db9",
  "ticket_page_url": null,
  "image_url": "https://images.squarespace-cdn.com/…/1000016764.jpg",
  "is_deleted": 0,
  "venue_id": "b7716a13-e708-4573-8445-ea786a47233e",
  "venue_name": "The Lilypad",
  "venue_address": "1353 Cambridge St, Cambridge, MA 02139",
  "venue_lat": 42.3738079,
  "venue_lng": -71.100088,
  "venue_url": "https://www.lilypadinman.com/",
  "venue_type": "Music Venue",
  "venue_region": "Cambridge",
  "series_count": 4,
  "series_image": "https://images.squarespace-cdn.com/…/1000016764.jpg",
  "source": "scraper_local",
  "first_seen_at": "2026-07-03T06:20:36.366Z",
  "last_seen_at": "2026-08-07T07:23:34.117Z",
  "updated_at": "2026-09-04T23:17:55.599Z"
}

Things worth knowing about the fields:

• event_date is a plain calendar day in the venue’s local time zone. Don’t new Date() it — that would shift it by your UTC offset. Combine it with start_time (24-hour HH:MM:SS, may be null) if you need a timestamp.
• price is the raw label from the venue (“$15 adv / $20 door”, “Free”, “Donation”); price_amount is our best parsed number in the city’s local currency (USD in the US, GBP in London), or null when we couldn’t parse one. free=1 uses both.
• category is one of the slugs above; event_type is the venue’s own genre tags.
• performers lists who the event is by — the bill, authors, instructors, speakers — each with a role (headliner, support, author, speaker, dj…). It’s empty when the venue doesn’t say. Search it with performer=.
• Single-event responses (/api/events/<uuid>) also carry books and authors for literary events: titles, ISBNs, covers, author bios and photos.
• series_count > 1 means the same title has that many upcoming dates at this venue (a weekly trivia night, a theater run). series_image is the first image found in that series. series_id is the stable id of that series; pass it as series_id= to list every date.
• end_date is set on a multi-day run stored as one event (an exhibition, festival or trade show): event_date is the first day, end_date the last. A run that opened before today stays in /api/events until its end_date. Runs listed performance by performance are separate events sharing a series_id instead.
• organizer names who puts the event on when that isn’t the venue (a talk series, promoter, festival or council programme). The venue_* fields always describe where it happens.
• duplicate_of: when the same show is listed under two venues we keep one. The other is never in lists; by id or in an updated_since sync it comes back with is_deleted: 1 and duplicate_of set to the event we kept.
• is_deleted: 1 means the venue stopped listing the event (or it is a cross-venue duplicate, see duplicate_of). /api/events never returns these; /api/events/<uuid> and ids= do, so you can render an honest “no longer listed” state.
• Booleans are 0/1, straight from the database.
• The public page for any event is https://findlocal.community/event/<id>, and an iCalendar file is at https://findlocal.community/event/<id>/calendar.ics.

A venue row from /api/venues:

{
  "id": "d21997e7-3a40-4863-8ef7-ad0227d80093",
  "name": "Agganis Arena",
  "city": "Boston",
  "region": "Boston",
  "address": "925 Commonwealth Ave, Boston, MA 02215",
  "url": "https://www.agganisarena.com/",
  "description": "Agganis Arena is a versatile venue hosting sports, concerts, and events.",
  "image": "https://img.findlocal.community/venues/d21997e7-3a40-4863-8ef7-ad0227d80093.jpg",
  "image_attribution": "\"Agganis Arena Exterior\" by …, CC BY-SA 4.0 (https://commons.wikimedia.org/…)",
  "image_source": "openverse",
  "type": "Arena & Stadium",
  "venue_size": "Large",
  "capacity": 7200,
  "categories": ["music"],
  "latitude": 42.3514544,
  "longitude": -71.1176226,
  "is_active": 1,
  "upcoming": 7
}

/api/venues accepts city and optional region, type, q (name search) and sort (name or upcoming). About the venue fields:

• type is one of a fixed list: Music Venue, Performing Arts Center, Theater, Comedy Club, Bar, Nightclub, Brewery & Winery, Restaurant, Cafe, Bookstore, Library, Museum, Art Gallery, University & College, Arena & Stadium, Park & Outdoors, Community Center, Place of Worship, Market, Festival Grounds, Other.
• capacity is the maximum number of people when a source states one (Wikidata, the venue’s own site, a venue directory), else null. venue_size is Small (under 100), Medium (100-499) or Large (500+); it comes from capacity when known and is an estimate otherwise.
• image_attribution, when present, is the credit line the image’s Creative Commons license requires. Show it next to the image.

The public venue page is https://findlocal.community/venue/<id>.

Examples

JavaScript (browser or Node)

const params = new URLSearchParams({ city: 'seattle', when: 'weekend', cat: 'comedy,music', limit: '50' });
const res = await fetch(`https://findlocal.community/api/events?${params}`);
const { data, meta } = await res.json();

console.log(`${meta.total} events this weekend`);
for (const e of data) {
  console.log(`${e.event_date} ${e.start_time ?? ''} · ${e.title} @ ${e.venue_name}`);
}

Python

import requests

r = requests.get(
    "https://findlocal.community/api/events",
    params={"city": "denver", "when": "today", "free": "1"},
    timeout=15,
)
r.raise_for_status()
body = r.json()
for e in body["data"]:
    print(e["event_date"], e["start_time"], e["title"], "—", e["venue_name"])
print(body["meta"])

Paging through everything

# Page size is 100 by default; walk `page` until data comes back empty
curl 'https://findlocal.community/api/events?city=austin&page=1'
curl 'https://findlocal.community/api/events?city=austin&page=2'

Caching, freshness, and fair use

• Responses are cached at the edge for 5 minutes and in your browser for 1 minute (Cache-Control: public, max-age=60, s-maxage=300). Polling faster than that just returns the cached copy.
• Listings update as venues are re-scraped, typically daily. last_seen_at tells you the last time we saw an event on its source page.
• Coverage is 80+ metros across the US and the UK (London). The full list is in llms.txt and on the city pages.
• Every listing page also advertises its JSON twin with <link rel="alternate" type="application/json">, so you can discover the API URL for any filtered view from the page itself.
• The API needs an API key — send it as Authorization: Bearer <key> (the x-api-key header works too). A missing or invalid key returns 401; going over your rate limit or monthly quota returns 429 with a Retry-After header. There’s a free tier plus Indie and Business plans, and one key works for both this API and the MCP server. Please cache on your side, keep request rates reasonable, and link back to the event’s Find Local page or the venue’s own site.
• Field names are stable but the API is not formally versioned. New fields may appear; existing ones won’t be renamed without notice on this blog.

What’s next

• Connect FindLocal to Claude, Cursor, and other AI assistants (MCP) — the same data as tools an assistant can call.
• How Find Local finds events the big platforms miss — where the data comes from.
• The FindLocal platform page — the overview for teams building on the data.

Reference: the up-to-date endpoint, parameter and field tables now live at /mcp. This post is the walkthrough.

Update: there are no shared demo keys anymore. Authorize with your own API key from /pricing — the same key works for the MCP server and the JSON API, and there’s a free tier.

Find Local runs a remote MCP server. MCP (Model Context Protocol) is the open standard AI assistants use to call outside tools, so once it’s connected you can ask Claude or Cursor things like “what’s free in Brooklyn this weekend?” or “any jazz near Cambridge tonight?” and it will answer from the same curated venue calendars the website uses, with links back to each event.

The server lives at:

https://mcp.findlocal.community/mcp

It’s read-only, uses the Streamable HTTP transport (an /sse endpoint exists for older clients), and authorizes with OAuth plus a short account key step described below. If you’d rather query the data directly from code, see the Events API guide.

1. Add the server to your client

Claude.ai (web and desktop)

1. Open Settings → Connectors.
2. Choose Add custom connector.
3. Paste https://mcp.findlocal.community/mcp and save.
4. Click Connect. A small FindLocal authorization page opens — see the account key step below.
5. In a new chat, make sure the FindLocal connector is toggled on, then ask about events.

Claude Code (terminal)

claude mcp add --transport http findlocal https://mcp.findlocal.community/mcp

Start a session and the first FindLocal tool call will open the authorization page in your browser.

Cursor

Add the server to ~/.cursor/mcp.json (or your project’s .cursor/mcp.json) and restart Cursor:

{
  "mcpServers": {
    "findlocal": {
      "url": "https://mcp.findlocal.community/mcp"
    }
  }
}

Any other MCP client

Any client that supports remote servers over Streamable HTTP with OAuth works — point it at the URL above. To poke at the tools without a chat client, use the MCP Inspector:

npx @modelcontextprotocol/inspector
# transport: Streamable HTTP, URL: https://mcp.findlocal.community/mcp

2. Authorize with your API key

When your client connects, FindLocal shows a one-field consent page asking for your API key. Usage is metered against your account’s monthly quota so we can keep the service healthy.

• Get a key at /signup. The Free plan needs no card; the Indie and Business plans add more calls (see pricing), and anything bigger is a conversation. Create the key yourself in the dashboard — it is shown once. The monthly quota belongs to your account, so every key you make draws on the same pool.
• The same key works for both the MCP server and the JSON API.

Once authorized you won’t be asked again for that client. You can check where you stand any time by asking the assistant to run get_usage, which reports the account’s calls used and remaining for the current month. When a quota is exhausted, tool calls return a clear “monthly quota reached” message rather than partial data.

3. Ask questions

Some prompts that work well:

• “What’s happening in Boston tonight that’s free?”
• “Find comedy shows in Chicago this weekend under $25.”
• “Any talks or film screenings in London this week under £15?”
• “When is my favourite band next playing in Chicago?”
• “List music venues in Austin’s East Side and what’s coming up at each.”
• “Is there anything family-friendly in Denver on Saturday afternoon?”
• “What categories of events does FindLocal have in Seattle, and how many of each?”

Every event the assistant gets back includes a url to its page on findlocal.community, plus ticket and venue links when the venue publishes them, so you can jump straight from the chat to buying a ticket.

The tools

These are the tools the server exposes. Your assistant picks the right one automatically; the list is here so you know what’s possible and how to phrase requests.

Categories are music, comedy, theater, dance, art, food_drink, family, market, workshop, fitness, nightlife, community, festival, parks, literary, film, and talks. Cities can be given by name (“New York”) or slug (“new-york”); the full list of metros (US and UK) is in llms.txt.

An event in a tool result looks like:

{
  "id": "8f9b9068-4e11-466b-a1cc-d36230d28fdd",
  "title": "Hooley Hour",
  "date": "2026-09-04",
  "start_time": "17:00:00",
  "city": "Boston",
  "region": "Cambridge",
  "venue": { "id": "b7716a13-…", "name": "The Lilypad", "address": "1353 Cambridge St, Cambridge, MA 02139" },
  "category": "music",
  "category_tags": ["Theater", "Music"],
  "performers": [{ "name": "The Hooley Band", "role": "headliner" }],
  "price_label": "Free",
  "price_usd": 0,
  "price_amount": 0,
  "currency": "USD",
  "is_free": true,
  "recurring": true,
  "upcoming_dates_in_series": 4,
  "series_id": "s_3f0c9a1d2b7e4c55",
  "details_url": "https://www.lilypadinman.com/home/2026/hooley-hour-bs5y2-pl4db9",
  "image": "https://images.squarespace-cdn.com/…/1000016764.jpg",
  "website": "https://www.lilypadinman.com/",
  "url": "https://findlocal.community/event/8f9b9068-4e11-466b-a1cc-d36230d28fdd",
  "source": "scraper_local"
}

Fields that are empty for an event are simply omitted. date is the venue’s local calendar day; price_label is the venue’s own wording and price_amount our parsed number in the metro’s currency (GBP for London; price_usd repeats it for US metros only); is_free is set when we can tell either way. A multi-day run stored as one event (an exhibition or festival) has end_date, its last day; organizer names who puts the event on when that isn’t the venue; series_id is shared by every date of one series and can be passed back to search_events.

Good to know

• Freshness. Venue calendars are re-scraped regularly, typically daily, so results reflect what venues currently list. The when buckets are resolved in each city’s time zone.
• Coverage. 80+ metros across the US and the UK (London), over 10,000 venues, with an emphasis on the small and mid-size venues that never make it onto ticketing aggregators. A missing venue is a gap in our crawl, not a sign the event doesn’t exist — tell us at elliot@findlocal.community.
• Privacy. The server only ever reads event and venue data. It stores the API key you authorize with and a per-month call counter, nothing about your conversations.
• Rate limits. Quotas are monthly per account, shared by all of its keys. When you hit your monthly quota, tool calls return a clear “monthly quota reached” message rather than partial data; upgrade from your dashboard.

What’s next

• How to use the FindLocal Events API — the same data as plain JSON.
• How Find Local finds events the big platforms miss — where the data comes from.
• The FindLocal platform page — the overview for teams building on the data.

Straight from the source

Find Local works differently: we go to the venues themselves. Our pipeline reads the calendars of thousands of local venues — music halls, comedy clubs, theaters, bars, community spaces — across dozens of US cities (and now London), and turns them into one structured, searchable feed that updates daily.

That means the listings include the shows that only ever existed as a line on a venue’s own website. No account required, no markup, no “fees revealed at checkout” — tickets link straight to the venue or its own ticketing page.

Browse it your way

• The event feed shows everything upcoming in your city, filterable by date, category, price, and time of day.
• The map view puts every venue with upcoming events on a map, so you can see what’s walkable tonight.
• Venue pages collect each spot’s upcoming calendar in one place.
• City pages like Boston, New York, and Chicago give you a quick date-grouped rundown of what’s coming up.

For builders

The same structured event data behind the site is available to developers through the FindLocal platform: a free JSON API and an MCP server you can plug into Claude, Cursor, and other AI assistants.

Find Local is free to use — pick your city and see what’s on tonight at findlocal.community.

The problem isn’t that nothing is happening. In any decent-sized city, hundreds of things are happening this weekend. The problem is where that information lives: scattered across individual venue websites, bar chalkboards, and email newsletters — places search engines and big platforms barely reach.

Here’s a system that actually works.

1. Start with a time, not an activity

“Something Saturday night” is a better search than “jazz.” Availability first, genre second — the best nights out are usually the thing you didn’t know to search for. Scan everything on in your city for the window you’re free, then narrow.

On Find Local, that’s the This Weekend filter plus the evening time-of-day filter — one tap each.

2. Think in venues, not events

Events are one-offs; venues are repeat characters. If you liked one show at a room, that venue’s calendar is the highest-signal list of future plans you’ll ever get. Keep three or four home venues and check what they have coming up — every venue page on Find Local lists its upcoming calendar in one place.

3. Use the map when you’re already out

Half of going out is logistics. If you’re meeting a friend in one neighborhood at 7, the question isn’t “what’s good tonight” — it’s “what’s good within ten minutes of here at 9.” A map view of tonight’s events answers that in a glance.

4. Let the small stuff win sometimes

Big shows are easy to find precisely because someone paid to put them in front of you. The Tuesday-night residency, the brewery trivia, the black-box play — the stuff with no ad budget — is where cities actually live. That’s most of what we index, because we pull from venue calendars directly, not from ticketing feeds.

The five-minute version

1. Open your city’s feed (we cover 80+ metros across the US and the UK — Boston, New York, Chicago, LA, and more).
2. Filter to the weekend, evening, and — if money’s tight — free events.
3. Save two or three candidates. Having a backup kills the “eh, never mind” instinct.
4. Go. The venue would love to see you.

No account, no spam, no fees — just what’s on. Find your city →

The rock clubs

Paradise Rock Club — The Comm Ave institution near BU, and still one of the best rooms in the city to catch a touring act right before they get too big for it.

The Sinclair — Harvard Square’s mid-size stage, a restaurant-and-venue combo with one of the busiest calendars in Cambridge.

Roadrunner — Brighton’s newer big room, built for the acts that outgrew the clubs.

House of Blues — The Lansdowne Street standby across from Fenway, mixing national tours with theme nights.

Folk and jazz rooms

Club Passim — The legendary Harvard Square folk club (Joan Baez and Bob Dylan played the room it grew out of). Intimate doesn’t begin to cover it.

Regattabar — Cambridge’s renowned jazz club, back with a steady calendar of live performances.

The Lilypad — An Inman Square art-space-turned-stage where jazz, experimental, and songwriter nights share the week.

Lizard Lounge — A cozy basement room under Cambridge Common known for up-close sets and long-running residencies.

Dinner-and-a-show (and a pint)

City Winery — A working winery, restaurant, and concert hall in one, with the busiest music calendar in the city — often multiple shows a night across its stages.

Somerville Theatre — The historic Davis Square movie palace that moonlights as one of the area’s best-sounding live rooms.

The trick to actually catching these shows

Most of these venues publish their calendars on their own sites, which means the shows rarely surface when you search “live music Boston tonight.” That’s the gap Find Local exists to close: we read the venues’ own calendars daily and put everything — headline tours and Tuesday-night residencies alike — in one feed for Boston you can filter by date, price, and time of day.

Browse all Boston-area venues or jump straight to what’s on in Boston this week.

Here are rooms with packed calendars you can browse right now:

Dedicated comedy clubs

New York Comedy Club — East Village — One of the city’s premier stand-up rooms, with multiple shows nightly featuring comics you’ll recognize and ones you’re about to.

Broadway Comedy Club — A Midtown staple showcasing a rotating mix of established and emerging comedians, with several showtimes a night.

Greenwich Village Comedy Club — An intimate Village basement in the neighborhood that basically invented the form’s New York era.

The Grisly Pear — Midtown — A bar-plus-showroom with one of the busiest comedy calendars in Manhattan, heavy on affordable shows.

The indie side

The Tiny Cupboard — Brooklyn’s hidden gem: an intimate Bushwick venue (yes, really, in an apartment building — with a rooftop) that’s become one of the most beloved independent comedy spots in the city.

And that’s just the dedicated rooms. All over Brooklyn and Manhattan, bars like Freddy’s and Pine Box Rock Shop run weekly comedy nights and open mics between their music bookings — the kind of shows that only ever exist as a line on the venue’s own calendar.

How to actually pick a show

Comedy in New York is a nightly commodity — the hard part isn’t finding a show, it’s finding tonight’s show at the right time, near you, at the right price. Find Local’s New York feed pulls every listing straight from the venues’ own calendars daily. Filter the feed to comedy, pick your night, and go — most of these rooms have something on within the next 48 hours.

See everything happening in New York this week →