Web Data to Notion Dashboard

Scrape eight curated verticals — restaurants, real estate, gyms, hotels, schools, YouTube, Instagram, and TikTok — and get a polished Notion dashboard with table, gallery, and map views in one Actor run. Powered by Apify MCP Connectors: Apify never sees your Notion token. Your authorization is brokered by Apify's MCP proxy and stays on the proxy side.

🟢 New here? Here's the whole thing in 3 steps:

1. Connect Notion once (~60 sec) — click to authorize, log in, click Allow. This is the "MCP Connector": a secure, one-time link so this Actor can build a dashboard in your Notion. Apify never sees your Notion password or token. 2. Paste a Notion page URL — any blank page works; the dashboard lands inside it. (No page yet? In Notion: New page → name it "Apify Dashboards" → copy the URL. You'll reuse it on every run.) 3. Pick a vertical + location, then click Run. Want to spend $0 first? Set Data source → "Sample data — preview only" (keep Vertical = Restaurants) and Run to see exactly what you'll get — steps 1 and 2 are still needed (that's how the dashboard reaches your Notion), but there's no scrape charge.

What it costs: the sample preview is $0. A real run is typically $0.40–$1.20 and never exceeds the $3 cap you control (per run). Connecting Notion is free.

---

What does Web Data to Notion Dashboard do?

Pick a vertical, enter a location or search query, pick your Notion workspace — the Actor scrapes the data, builds a structured Notion database, and adds table, gallery, and map views where they make sense. The whole thing happens in one run, typically in 30–90 seconds.

Supported verticals:

Vertical	Upstream source	What you enter	Notion columns
Restaurants	Google Maps	City + State + ZIP	Name, Address, Lat/Lng, Rating, Price tier, Photos, Source, Maps link
Real estate	Zillow	City + State + ZIP	Name, Address, Lat/Lng, Rating, Price tier, Photos, Source, Maps link
Gyms	Google Maps	City + State + ZIP	Name, Address, Lat/Lng, Rating, Price tier, Photos, Source, Maps link
Hotels	Google Maps	City + State + ZIP	Name, Address, Lat/Lng, Rating, Price tier, Photos, Source, Maps link
Schools	Google Maps	City + State + ZIP	Name, Address, Lat/Lng, Rating, Price tier, Photos, Source, Maps link
YouTube	streamers/youtube-scraper	Search query or channel URL	Title, Channel, Views, Likes, Duration, Uploaded, Description, Video link, Thumbnail
Instagram	apify/instagram-scraper	Profile URL or hashtag URL	Caption, Username, Likes, Comments, Type, Posted, Photos, Post link
TikTok	clockworks/tiktok-scraper	Search query or hashtag	Caption, Creator, Likes, Views, Comments, Posted, Photos, Post link

All five local-business verticals share the same column set (fields a source doesn't provide are left empty — e.g. price tier for schools). Content verticals get their own columns, listed above.

Why through MCP Connectors specifically? You authorize Notion once in Apify's settings. The Actor then writes to your workspace via Apify's MCP proxy — your Notion token never reaches the Actor's code, never appears in logs, and never leaves the proxy. The proxy also enforces a strict allowlist of which Notion tools this Actor can call (notion-create-database, notion-create-pages, notion-create-view, notion-fetch). Even if the Actor wanted to read your other workspaces, the proxy would block it.

Why use this?

• Moving to a new city? Scrape restaurants/gyms/real estate in the destination ZIP, get a Notion dashboard, share it with your partner or roommate.
• Local-market research? A real estate agent, marketer, or analyst wanting a shareable snapshot of one ZIP's businesses without exporting CSVs and rebuilding charts.
• Demoing MCP Connectors? This Actor is the canonical example of the "scrape + write back" pattern from the Apify MCP Connectors launch — read the source for a copyable template.

How to use Web Data to Notion Dashboard

1. Authorize Notion in Apify Console → Settings → MCP Connectors → Notion. (~60 seconds via Notion's standard OAuth popup.)
2. Create or pick a parent page in Notion — any blank page in your workspace works. Recommended: before pasting the URL, open that page in Notion and click Share → Publish to web. Every dashboard the Actor creates under that page will automatically inherit public access.
3. Open this Actor's Input form. Pick a vertical, then enter a location or query: for local-business verticals use City + State + ZIP (try Austin, TX 78704 or Cambridge, MA 02139 — a bare ZIP can match foreign postal codes); for YouTube/Instagram/TikTok enter a search query, profile/hashtag URL, or hashtag. Pick your Notion connection and paste the parent page URL.
4. Click Run. The status log shows what's happening step by step. Typical runs take 30–90 seconds.
5. Open your dashboard from the Output tab. If the parent page was already shared, you'll see a public URL ready to send to anyone. Otherwise, click Share → Publish to web in Notion to make it public.

Input

Field	Type	Required	Description
vertical	enum	✓	What to scrape. See verticals table above.
location	string	✓	Local-business: City + State + ZIP. Bare ZIPs match foreign postal codes — 37604 alone matches Pohang, South Korea. Use Johnson City, TN 37604. YouTube: search query or channel URL. Instagram: profile or hashtag URL (https://www.instagram.com/apify/). TikTok: search query or hashtag (web scraping or #datascience).
maxItems	int		Default 50, max 500. Map view shows top 100.
notionConnector	Notion account (connect once)	✓	Log in to Notion once and pick your workspace — ~60 seconds, no token to find. Apify never sees your password or token.
parentPageUrl	string	✓	URL of a Notion page in your workspace. Pre-share it for instant public dashboards.
dataSource	enum		yourOwn (live scrape, default) or demo (sample Austin restaurants, no cost).
siteTitle	string		Optional — will auto-generate if left blank, named from what the run actually finds (e.g. "Restaurants in Austin, TX" from the scraped addresses, "YouTube videos by VeriTones" from the channel). Ignored for sample data.
includeMapView	enum		auto (default — on for restaurants, real estate + hotels; off for gyms + schools), on, or off. Always off for YouTube/Instagram/TikTok — no coordinates.
includeGalleryView	bool		Default true. Auto-disabled if too few photos load.
costCap	number		Worst-case ceiling, default $3. Typical run cost: $0.40–$1.20.
bypassCache	bool		Default false. Set true to re-scrape and re-deploy fresh.

Output

The Actor writes a Notion database under your parent page. For local-business verticals the columns are:

Column	Type	Notes
Name	title	Business name.
Address	rich_text	Full street address. Notion's Map view geocodes from this.
Lat / Lng	number	Used by the Google Maps fallback link below.
Rating	number	0–5 scale where available.
Price tier	rich_text	$ / $$ / $$$ / $$$$ where available.
Photos	rich_text	Up to 8 photo URLs per row, used by the gallery view. (Note: external URLs may go stale — re-run for fresh.)
Source	url	The source page on Google Maps / Zillow / etc.
Google Maps	url	A constructed maps.google.com/?q=lat,lng link — works even when Notion's geocoder misses.
Vertical	select	The vertical you ran.
Scraped at	date	UTC timestamp.

Content verticals (YouTube, Instagram, TikTok) get their own column sets — see the verticals table above.

The Output tab in Apify Console gives you the dashboard URL, a public URL (when applicable), counts of rows + geocoding hits, and a cachedFromPreviousRun flag.

Pricing / Cost estimation

• Typical run (50 items, restaurants vertical): $0.40–$1.20 in Apify charges.
• Worst case (500 items, high-cost vertical, retries): set your costCap accordingly.
• dataSource: demo: $0 — uses bundled sample data, no upstream scrape runs.
• Notion side: no charge for normal API calls. Notion's free tier covers thousands of dashboard writes per month.

The costCap field is a hard ceiling, not an estimate. If the run hits it, scraping stops and whatever was scraped is still written to Notion.

Tips and advanced options

• Pre-share your parent page in Notion before running. Every dashboard under it inherits public access — saves you one click per run.
• Lower costCap if you only want a partial scrape under a budget. The Actor will stop cleanly when the budget hits.
• Leave the Dashboard title blank — it auto-names from what the run actually finds (the majority city/state from the scraped addresses, or the channel name for content verticals).
• Use bypassCache: true to re-scrape — by default we cache identical runs for 14 days to save you cost.
• Each run creates a new dashboard under your parent page. Delete old ones in Notion to keep things tidy. (In-place updates are planned for v1.1.)
• Iterate the dashboard design in Notion — the Actor only sets up the schema and writes rows. You can rearrange columns, add Notion AI summaries, or change colors freely.

How this works under the hood (for builders)

This Actor is built as a reference implementation for the Apify MCP Connectors launch. If you're building your own Connector Actor, here's the pattern:

Architecture

User → Apify Actor → Apify MCP Proxy (injects user's Notion token) → Notion MCP server
                  ↓
              Apify SDK (uses APIFY_TOKEN for upstream scraper call)
                  ↓
              Curated upstream Actor (Google Maps Scraper, Zillow ZIP Search, etc.)

Declaring the Notion Connector

In .actor/input_schema.json:

"notionConnector": {
  "type": "string",
  "resourceType": "mcpConnector",
  "mcpServers": [{
    "url": "https://mcp.notion.com/mcp",
    "tools": {
      "required": [
        "notion-create-database",
        "notion-create-pages",
        "notion-create-view",
        "notion-fetch"
      ]
    }
  }]
}

The tools.required array is both an eligibility filter (only Connectors exposing these tools appear in the picker) and a runtime ceiling (the proxy blocks calls to tools outside this list, even if Notion supports them).

Connecting at runtime

Standard @modelcontextprotocol/sdk — no Apify-specific client needed. See src/notion-client.ts for the connection pattern with fuzzy tool-name resolution (defensive against Notion-side renames).

Why we use lat/lng + Google Maps URL instead of Notion's place property

Notion's API has partial support for the place property type — you can read it but writes return null. Until Notion ships full write support, we store coordinates in separate Lat and Lng number columns, write the address into a rich_text column for Notion's built-in geocoder, and emit a constructed Google Maps URL per row so every row has a working map link regardless of Notion's geocoder accuracy.

Cost model breakdown

Per run: (upstream scrape cost) + (this Actor's compute) + (Notion API: free).

• Upstream scrape: ~maxItems * worstCasePerItemUsd (varies by vertical, see .actor/vertical_actors.json).
• This Actor's compute: ~$0.05/minute while waiting on the upstream + writing to Notion.
• The costCap input enforces a ceiling on the upstream scrape via maxTotalChargeUsd.

FAQ, disclaimers, and support

Q: Does Apify see my Notion data? A: No. Apify operates the MCP proxy that forwards your requests to Notion using your Notion-side authorization. The Apify-side proxy logs request metadata (which tools were called) but does not log the content. The Actor code never touches your Notion token at all.

Q: Why does Notion ask me to manually "Publish to web" after the run? A: That's intentional — Notion's API can't make a page public on your behalf, even if Apify wanted to. It's a built-in security boundary that protects you from any Actor that misbehaves. Pre-share the parent page once and every dashboard inside it is automatically public.

Q: What locations work best? A: Metro areas return the richest data; rural areas may return very few or no results. Always use the full City + State + ZIP form (Austin, TX 78704, Cambridge, MA 02139, San Francisco, CA 94110) — a bare 5-digit ZIP can match a foreign postal code and return results from the wrong country.

Q: Why is the map view sometimes missing pins? A: Notion's built-in geocoder runs on the address column you provide. Quality varies by region and address format. Every row also has a Google Maps URL (computed from lat/lng) that works regardless.

Q: Can I run this on a schedule? A: Yes — set up an Apify Schedule pointing at this Actor. The idempotency cache returns the same dashboard URL for identical inputs within 14 days, so scheduled re-runs are free until inputs change. Use bypassCache: true to force fresh.

Q: Why does the same city with different formatting create two dashboards? A: The cache key is computed from your inputs exactly as typed — location, vertical, max items, parent page, Notion connection, data source, and view options. "Austin, TX 78704" and "austin, tx 78704" are different keys, and so are "Austin, TX" and "Austin, TX 78704". Be consistent with your location format if you want the idempotency cache to fire.

Q: How do I get a webhook when a run finishes? A: Wire it in the Apify Console — open this Actor → Integrations tab → add a webhook for "Run finished" or "Run failed". Apify's platform handles retries with exponential backoff. The Actor itself also records terminal-state telemetry to a named KVS (telemetry) on each run, which you can read via the Apify API if you need run-completion metadata that's not in the dataset.

Q: Where do I report bugs? A: Use the "Report issue" link on this Actor's Apify Store page, or post in the Apify Discord. Include the discovered Notion tool list from the run log if the issue is connection-related.

Disclaimer: This Actor scrapes data from third-party sources (Google Maps, Zillow, etc.). Respect each source's Terms of Service and applicable laws regarding data use. The Actor doesn't store or transmit personal data beyond what the upstream scrapers return.