# DayPlay — SF Bay Area Events, Places & Itinerary Planner (`dayplay/dayplay-local-intelligence`) Actor

Verified real-time places, events, and AI-composed outing itineraries for San Francisco, Oakland & Berkeley. Things to do, date nights, nightlife & weekend plans from a deterministic dataset — honest zero-results, never fabricated. Free. Powered by dayplay.io.

- **URL**: https://apify.com/dayplay/dayplay-local-intelligence.md
- **Developed by:** [Dayplay Activity Radar](https://apify.com/dayplay) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## DayPlay — SF Bay Area Local Intelligence

Get verified real-time places, events, and ready-to-walk outing itineraries for the **San Francisco Bay Area** — San Francisco, Oakland, and Berkeley across 35 curated neighborhood hubs.

Unlike generic LLM-generated recommendations, every venue and event comes from DayPlay's **verified, deterministic dataset** with spatial containment checks. When nothing is happening, this Actor tells you so honestly — it never invents venues, events, dates, or hours.

### What it does

Four modes (pick one in the input form):

| Mode | What you get |
|---|---|
| **plan** *(flagship)* | A complete multi-stop outing: stops in deterministic order, walking distances and times between each, total visit time estimate. Filter by vibe, interests, and budget. |
| **events** | Verified real-time event occurrences for a neighborhood + date |
| **places** | Curated places, with ratings and addresses |
| **neighborhoods** | The complete list of 35 in-market neighborhood centroids |

### Quick start

1. Add this Actor to your Apify account
2. Set the `DAYPLAY_API_KEY` environment variable (secret) — request access at [dayplay.io](https://www.dayplay.io)
3. Choose a mode, pick a neighborhood (e.g. `Mission`), set a date
4. Run — results land in the Actor's dataset

### Input

- **mode**: `plan` / `events` / `places` / `neighborhoods`
- **neighborhood** *(required)*: exact name from the `neighborhoods` mode (e.g. `Mission`, `North Beach`, `Oakland`, `Berkeley`)
- **date**: `YYYY-MM-DD` (required for `plan` and `events`)
- **interests**: optional, comma-separated (e.g. `music, food, art`)
- **budget**: `free` / `budget` / `moderate` / `splurge` (plan mode)
- **maxStops**: 2–6 for plan mode (default 4)
- **limit**: 1–100 for events/places mode (default 20)

### Geographic scope (strict)

DayPlay serves **only** San Francisco, Oakland, and Berkeley. If you request anything else — New York, Los Angeles, Tokyo, anywhere — the Actor returns an explicit `out_of_market` result with the full list of available neighborhoods. It does not fabricate data for unsupported locations. That's the [DayPlay Anti-Drift Guarantee](https://www.dayplay.io).

### Output

Results are written to the default dataset, one item per record:

- `plan` mode → one item: `{status: "ok", type: "itinerary", plan: {stops[], walk_legs[], total_walk_minutes, ...}}`
- `events`/`places` → one item per record (`{status: "ok", type: "event"|"place", name, category, rating, address, ...}`)
- Refusals/empty results → `{status: "out_of_market"|"zero_results", message, ...}`

Every record includes a `dayplay_deep_link` to [dayplay.io](https://www.dayplay.io) — where humans can save plans, get alerts, and explore interactively.

### Cost

Runs on Apify's free tier comfortably (typically under a minute per run). Set your own monetization when publishing.

***

*Powered by [DayPlay](https://www.dayplay.io) — the local intelligence layer for humans and their agents.*

# Actor input Schema

## `mode` (type: `string`):

plan = composed multi-stop itinerary with walk times (flagship). events/places = raw verified records. neighborhoods = the 35 in-market centroids.

## `neighborhood` (type: `string`):

Exact SF Bay Area neighborhood name (e.g. Mission, North Beach, Oakland, Berkeley — see the neighborhoods list at dayplay.io). Out-of-market names are refused by protocol — DayPlay never invents venues.

## `date` (type: `string`):

Outing/query date as YYYY-MM-DD. Required for mode=plan and mode=events.

## `interests` (type: `string`):

Optional comma-separated interests (e.g. music, food, art, comedy) to prioritize in plan mode.

## `budget` (type: `string`):

Optional budget tier for plan mode.

## `maxStops` (type: `integer`):

Maximum number of stops in a composed itinerary.

## `limit` (type: `integer`):

Max records returned in events or places mode.

## Actor input object example

```json
{
  "mode": "plan",
  "neighborhood": "Mission",
  "date": "2026-09-26",
  "maxStops": 4,
  "limit": 20
}
```

# Actor output Schema

## `results` (type: `string`):

All records written to the default dataset: composed itineraries (plan mode), verified event/place records (events/places modes), or status items (out\_of\_market / zero\_results / input\_error).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "neighborhood": "Mission",
    "date": "2026-09-26"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dayplay/dayplay-local-intelligence").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "neighborhood": "Mission",
    "date": "2026-09-26",
}

# Run the Actor and wait for it to finish
run = client.actor("dayplay/dayplay-local-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "neighborhood": "Mission",
  "date": "2026-09-26"
}' |
apify call dayplay/dayplay-local-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dayplay/dayplay-local-intelligence"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/VHja2mdeGP3YuYhHT/builds/Oncf1Uamn5yLoo4Jf/openapi.json