{"slug": "i-gave-my-yc-jobs-scraper-write-access-to-notion-without-ever-holding-a-notion", "title": "I gave my YC jobs scraper write access to Notion without ever holding a Notion token", "summary": "Apify developer Artem Lazarev added Apify MCP connector support to his published Y Combinator jobs scraper, letting the Actor write scraped jobs into a user's Notion database without ever handling a Notion API token. The scraper's last full sweep covered 1,429 companies and 3,305 jobs in about an hour and fifty minutes, producing an 18 MB JSON file; the Actor charges per result and has 120 users. Under the connector model, users authorize Notion once in their own Apify account and the Actor receives only an opaque connector ID, with the Apify MCP proxy adding the Notion credential server-side so it never enters the developer's container.", "body_md": "[Artem Lazarev](https://apify.com/artemlazarevm)as part of\n\n[Write for Apify](https://apify.com/resources/write-for-apify)- a program for developers sharing original articles about what they've built with Apify.\n\n## TL;DR\n\n[Apify MCP connectors](https://docs.apify.com/platform/integrations/mcp-connectors) use the Model Context Protocol (MCP) to let an Actor write into a user's connected apps without ever touching that app's credentials. I used one to push my scraped Y Combinator jobs straight into Notion and delete my CSV export step. Below: why a token field was never an option for a published Actor and five steps covering connector setup, tool discovery, field mapping, safe writes, and what the whole thing costs per run.\n\n## The workflow I wanted\n\nMy [Y Combinator jobs scraper](https://apify.com/artemlazarevm/yc-jobs-scraper) has run happily for months. It walks the YC directory, pulls every company that's hiring, and returns salaries, equity ranges, founder profiles, and full job descriptions. The last full sweep did 1,429 companies and 3,305 jobs in about an hour and fifty minutes.\n\nThen the data sat there. An 18 MB JSON file in a dataset. What I actually wanted was boring and specific: a running list of who's hiring, at what salary, in which batch, that I could sort and annotate and come back to a week later. So every time, I exported a CSV, opened it in a spreadsheet, and filtered by hand. The scraper was finished. My workflow wasn't.\n\n[Apify MCP connectors](https://docs.apify.com/platform/integrations/mcp-connectors) closed that gap. They let an Actor call an external service's allowed tools through an Apify-managed proxy, using the user's own authorized account.\n\nThe Actor is published on Apify Store, charges per result, and has 120 users I've never met.\n\nAfter I added connector support, it writes scraped jobs into a Notion database on its own. All it took was a [connector field](https://docs.apify.com/platform/integrations/mcp-connectors/use-in-actors) in the input schema, a declaration of the Notion tools it needs, and the code that turns scraped jobs into Notion pages.\n\nThe full implementation is in the repo: [github.com/artem-lazarev/apify-ycombinator-jobs-scraper](https://github.com/artem-lazarev/apify-ycombinator-jobs-scraper).\n\n**For users of Apify Actors.** To use an MCP connector, the Actor's developer has to add support for it first. Once that's in place, open Settings > API & Integrations in your own Apify account and authorize the connector you need, such as Notion. Then open the Actor's input form, select that connector, and fill in the destination details. For my YC Jobs Scraper, that's the Notion data source ID. Run it, and the scraped jobs land in your Notion database.\n\n## Why I couldn't just ask for a Notion token\n\nThe obvious option was to add a Notion API token field to the input schema and call the Notion API directly. A Notion integration token is a single secret that grants access to everything you've shared with that integration: pages, databases, all of it.\n\nAsking those users to paste a Notion token into my Actor means asking them to trust that my code won't log it or send it elsewhere. I wouldn't paste my own token into someone else's Actor, so I don't think it's reasonable to ask.\n\nMCP connectors invert that. The user authorizes Notion once, in *their* Apify account. My Actor receives a connector ID, which is just an opaque string. At runtime it authenticates to the Apify MCP proxy with the run's own Apify token, and the proxy adds the Notion credential server-side before forwarding anything upstream. That credential never enters my container. There's nothing for me to leak and nothing anyone has to trust me about.\n\nUsers still need to check which tools an Actor declares, because it can read and write through them. Apify [treats the Actor runtime as untrusted](https://blog.apify.com/announcing-mcp-connectors/#security-considerations) precisely because it runs developer-supplied code. I'm the untrusted party here, and I'd rather be.\n\n## What you need to follow along\n\nBy the end of this walkthrough your Actor will finish a scrape and push the results into Notion on its own. No CSV export, no import step, no Notion token anywhere in your code.\n\nBefore any of that works, one thing has to be true: **your Notion database has to exist already, with the columns you actually want.** This Actor creates pages. It doesn't create databases and it doesn't create columns. Step 3 covers what happens when you gloss over that, which in my case was a batch of jobs landing in Notion with nothing in them but titles.\n\nSo build the destination first. Start with a title column and add the fields you plan to fill.\n\nThe rest of the list is short:\n\n- An Apify account.\n- A Python Actor you can build and run in Apify Console.\n- A Notion workspace you can authorize. Apify provides the managed OAuth client for Notion, so you don't need to register your own OAuth app.\n- `apify-cli` 1.8.0 or newer, if you deploy from the command line.\n\nThe connection code targets Python 3.10 or newer, the Apify SDK, and `mcp` 2.x. One packaging detail worth knowing up front: `mcp` 2.x depends on `httpx2`, which is a separate package from `httpx`. Install and import that one.\n\nThe changes land in three places: inputs go in `.actor/input_schema.json`, the Notion helpers live in [src/notion_sync.py](https://github.com/artem-lazarev/apify-ycombinator-jobs-scraper/blob/main/src/notion_sync.py), and the sync gets called after results are saved in [src/main.py](https://github.com/artem-lazarev/apify-ycombinator-jobs-scraper/blob/main/src/main.py). The repository has the complete scraper; the excerpts below are the integration only.\n\n## 1. Declare the Apify MCP connector and its allowed tools\n\nWhen I opened my authorized Notion connector, it offered 28 tools: `notion-search`, `notion-update-page`, `notion-create-database`, and 25 more. My Actor can call two of them. The proxy rejects everything else before it ever reaches Notion.\n\nSetting up that allowlist is what this step is for, and it lives in `.actor/input_schema.json`. Here's the `notionConnector` field inside the existing schema's `properties` object:\n\n```\n{\n  \"properties\": {\n    \"notionConnector\": {\n      \"title\": \"Notion connector\",\n      \"type\": \"string\",\n      \"description\": \"Optionally write jobs to Notion through an authorized connector.\",\n      \"resourceType\": \"mcpConnector\",\n      \"nullable\": true,\n      \"sectionCaption\": \"Notion output\",\n      \"mcpServers\": [\n        {\n          \"url\": \"https://mcp.notion.com/mcp\",\n          \"tools\": {\n            \"required\": [\n              \"notion-create-pages\",\n              \"notion-fetch\"\n            ]\n          }\n        }\n      ]\n    },\n    \"notionDataSourceId\": {\n      \"title\": \"Notion data source ID\",\n      \"type\": \"string\",\n      \"description\": \"Destination data source UUID or collection:// reference.\",\n      \"editor\": \"textfield\",\n      \"nullable\": true\n    }\n  }\n}\n```\n\n`resourceType: \"mcpConnector\"` turns the input into a connector picker in Console. After building the Actor, authorize Notion under **Settings > API & Integrations**, then select it in the Notion output section.\n\nThe second input, `notionDataSourceId`, chooses where the pages go. Keep both optional so dataset-only runs still work. Step 3 shows how to fetch the destination reference once the connection is up.\n\nThe `tools.required` list is the part I'd skim past in someone else's article, so let me be specific about it. It isn't documentation and it isn't a hint. The proxy enforces it: it filters `tools/list` down to what you declared, and rejects `tools/call` for anything outside it.\n\nHere's the first line my Actor logs on every run, straight from a real run log:\n\n```\n🔧 Tools allowed through the connector: ['notion-create-pages', 'notion-fetch']\n```\n\nSo a jobs scraper can't rummage through your Notion. Not because I promise it won't, but because the proxy won't pass the call. You can check that yourself without reading a line of my code, which is about the only kind of security promise worth anything in a public Actor store.\n\nOne thing the allowlist doesn't do: it limits which operations the Actor can perform, not which content those operations can reach. `notion-fetch` isn't restricted to one database. What it can read still depends on the Notion account and permissions sitting behind the connector.\n\n## 2. Connect and read the tool descriptions before you write anything\n\nBefore writing anything to Notion, connect once and check what you're working with: which tools the proxy lets through, and what each one expects.\n\n### Open a session from Python\n\nThe Actor needs three values: the selected connector ID, the MCP proxy's base URL, and the Apify run token. Apify supplies the last two in every platform run.\n\nInstall these in the Actor build:\n\n```\napify>=2.0.0\nmcp>=2.0.0\nhttpx2>=2.5.0,<3\n```\n\nMy first deploy failed with `ValueError: not enough values to unpack (expected 3, got 2)`. The example I'd copied mixed the 2.x function name with 1.x unpacking (the docs have since been fixed). On `mcp` 1.x, the function is `streamablehttp_client`, takes `headers` instead of `http_client`, and yields a third value.\n\n``` python\nimport asyncio\nimport os\nimport httpx2\nfrom apify import Actor\nfrom mcp import ClientSession\nfrom mcp.client.streamable_http import streamable_http_client\n\nasync def main() -> None:\n    async with Actor:\n        actor_input = await Actor.get_input() or {}\n        connector_id = actor_input.get('notionConnector')\n        proxy_url = os.environ.get('ACTOR_MCP_CONNECTOR_BASE_URL')\n        token = os.environ.get('APIFY_TOKEN')\n        if not connector_id or not proxy_url or not token:\n            Actor.log.warning(\n                '⚠️ No connector or no proxy credentials - skipping Notion sync. '\n                'MCP connectors only resolve in a platform run, not a local one.'\n            )\n            return\n        try:\n            async with httpx2.AsyncClient(\n                headers={'Authorization': f'Bearer {token}'},\n                timeout=httpx2.Timeout(60.0),\n                follow_redirects=True,\n            ) as http_client:\n                async with streamable_http_client(\n                    f\"{proxy_url.rstrip('/')}/{connector_id}\",\n                    http_client=http_client,\n                ) as (read, write):\n                    async with ClientSession(read, write) as session:\n                        await session.initialize()\n                        tools = (await session.list_tools()).tools\n                        Actor.log.info(\n                            f'🔧 Tools allowed through the connector: '\n                            f'{[tool.name for tool in tools]}'\n                        )\n        except Exception:\n            Actor.log.exception('Notion connector check failed')\n            raise\n\nif __name__ == '__main__':\n    asyncio.run(main())\n```\n\n### Save the tool descriptions before you build a payload\n\nThe `notion-create-pages` description is 5,857 characters long. Console truncated it in my logs, so for the first few attempts I was coding against maybe a third of the contract.\n\nThe fix is one extra block, and it's the trick I'd start with on any MCP service: **save the tool descriptions and input schemas into the run's key-value store, then read them properly.**\n\nWhich means your first connection should do nothing but discover tools. It confirms authorization and hands you the service's real contract before you build a single payload. Each tool description explains what the tool does, and its input schema defines the arguments it accepts.\n\nThen, immediately after the `tools` assignment and inside the same initialized session, add the block that saves everything:\n\n```\npayload = [\n    {\n        'name': tool.name,\n        'description': tool.description,\n        'inputSchema': tool.input_schema,\n    }\n    for tool in tools\n]\nawait Actor.set_value('NOTION_TOOL_SCHEMA', payload)\n```\n\nOpen the run's default key-value store and read `NOTION_TOOL_SCHEMA`. One naming detail that tripped me up: the SDK attribute is `input_schema`, while `inputSchema` above is just the JSON key I picked for the saved file. Inspect the allowed arguments for `notion-fetch` and `notion-create-pages` before going further, because the parent ID and the property formats you need in step 3 are both buried in there.\n\n**Push to a dev build tag, not `latest`.** I have paying users on `latest`, and I wasn't going to test a new network call in front of them. There's a second reason to work this way: `ACTOR_MCP_CONNECTOR_BASE_URL` only exists in a platform run, so `apify run` on your laptop can't reach a connector at all. My whole loop was push to a dev tag, run on the platform, read the log.\n\n## 3. Prepare the Notion destination and map its fields\n\nThis is the step that cost me the most time, and the worst failure in it was the silent one.\n\nA batch of pages went into Notion with nothing but titles. No company, no salary, no equity. The log cheerfully reported that it was sending all columns. It wasn't lying, exactly: my schema parser had returned an empty dict, and the row builder read `{}` as \"this database has a title column and nothing else\", so it filtered every other field out on the way through.\n\nTwo things have to be right before you write anything: the destination reference and the column map.\n\n### Get the data source reference\n\nMy first mistake here was simpler. I sent the database ID, because that's what the Notion URL hands you, and the tool rejected it.\n\nA Notion database contains one or more data sources, and the write needs the ID of the source that should receive the jobs, not the database itself. A database URL on its own isn't the destination value either. Fetching the database is what makes the distinction obvious.\n\nSet `database_url` to the URL copied from your Notion database. Add this after `session.initialize()` in the connection example, at the same indentation as the other statements inside that session:\n\n```\nresult = await session.call_tool(\n    'notion-fetch', arguments={'id': database_url}\n)\nif result.is_error:\n    raise RuntimeError('Notion could not fetch the database')\nawait Actor.set_value(\n    'NOTION_DATABASE',\n    result.model_dump(mode='json', by_alias=True),\n)\n```\n\nOpen `NOTION_DATABASE` in the run's key-value store and find the `collection://` reference for the data source you want. Put that reference, or its bare UUID, into `notionDataSourceId`. The sync strips `collection://` before sending `parent: {\"data_source_id\": source_id}`.\n\n### Read the schema before building rows\n\nBack to the empty dict. But there's a reason I was reading the schema at all, and it wasn't the bug.\n\nI had it working against my own database, and I nearly shipped that. But it needed to work for my users' databases too. My database has a column called `Salary Min`. Theirs might call it `Salary (min)`, or have no salary column at all. The title column is usually `Name`, but Notion lets you rename it to anything. Since one unknown column kills an entire batch, an Actor that assumes my layout works for exactly one person.\n\nSo the Actor reads the target before writing to it. That's what the second declared tool, `notion-fetch`, is for.\n\nIn [src/notion_sync.py](https://github.com/artem-lazarev/apify-ycombinator-jobs-scraper/blob/main/src/notion_sync.py), `_fetch_data_source_schema` calls `notion-fetch` for `source_id` and passes the response to `parse_data_source_schema`. Those helpers, and `logger`, are defined in that file. The sync uses their result like this:\n\n```\nschema = await _fetch_data_source_schema(session, source_id) or None\nif schema:\n    logger.info(f'🗂️ Target columns: {sorted(schema)}')\nelse:\n    logger.warning('⚠️ Could not read the data source schema - sending all columns')\n```\n\nThat `or None` is the fix for the silent failure. An empty dict is falsy, but it isn't `None`, and the row builder treated `{}` as a real schema with no optional columns. Collapsing it to `None` forces a failed or empty lookup down the fallback path: send the expected fields and let Notion report the mismatch out loud. You can still end up with a rejected batch, but you'll know about it instead of finding 50 half-empty pages later. And either way the complete scraped data is already sitting in the Apify dataset.\n\nThe parsing itself has a wrinkle. `notion-fetch` doesn't return JSON. It returns a document wrapped in a JSON envelope: some prose, a `<data-source-state>` block, and a SQLite `CREATE TABLE` rendering of the same schema. The parser has to unwrap the envelope before it can read the schema at all. This excerpt handles the outer layer; the repository's `parse_data_source_schema` handles the remaining formats:\n\n``` python\nimport json\ntry:\n    envelope = json.loads(payload)\n    if isinstance(envelope, dict) and isinstance(envelope.get('text'), str):\n        payload = envelope['text']\nexcept json.JSONDecodeError:\n    pass\n```\n\nThen the row builder sends the job title to the column with type `title` and filters the other fields against the discovered names. This excerpt uses `_title_column` and the `candidates` dictionary from `build_job_rows` in the same file:\n\n```\ntitle_key = _title_column(schema) if schema else 'Name'\n...\nfor column, value in candidates.items():\n    if value is None:\n        continue\n    if schema is not None and column not in schema:\n        continue\n    properties[column] = value\n```\n\nThe nice side effect: point the Actor at a brand-new Notion database with only a title column and it still works. It writes titles. Add a `Salary Min` column and the next run fills it in, with no code change.\n\n### Use the MCP tool's property formats\n\nOne more trap, and this one produced the least helpful error message of the entire build:\n\n```\n{\"code\":\"validation_error\",\"status\":400,\n \"message\":\"Properties {propertyKeys} not found in the data source.\\n\n            Date property {propertyKeys} not found in the data source.\\n\n            All editable property keys: {editableProperties}.\"}\n```\n\nThose are literal `{propertyKeys}` placeholders. The template never got interpolated, so the error tells you that *some* property is wrong while withholding which one and what the valid names are. Notion knows both. And one unknown column rejected all 20 pages in the batch, because the offending page doesn't fail on its own.\n\nReading the saved tool description got me there faster than guessing from that message ever would have. It also handed me the encoding rules I'd otherwise have found by trial and error. Properties take scalar values rather than the Notion REST API's nested property objects. Send numbers as numbers. Checkboxes are the literal strings `__YES__` and `__NO__`. And date properties split across prefixed keys, so a column called \"Scraped At\" is written like this, where `properties` is the row's property dictionary and `scraped_at` is its date value:\n\n```\nproperties['date:Scraped At:start'] = scraped_at\n```\n\nNot `properties['Scraped At']`. That one would have taken me an hour on my own.\n\nMatch column names exactly and give them compatible types. A Number column named `Salary Min` will take the scraper's salary value; `Salary (min)` gets skipped. The Actor discovers the title column, but it won't translate other names for you or validate every column type.\n\n## 4. Save the scrape, then write pages in batches\n\nMy first connection attempt broke, and the run still finished with exit code 0 and a complete dataset.\n\nThat wasn't luck. It's the entire reason for the ordering in this step. Save the scrape to the dataset first, then sync, and keep the sync inside its own `try/except`. A connector failure should never throw away work the scraper has already finished, and on a per-result Actor that's work the user has already paid for.\n\nHere's the call site in [src/main.py](https://github.com/artem-lazarev/apify-ycombinator-jobs-scraper/blob/main/src/main.py), after the results are saved:\n\n```\n# Dataset first - this must succeed before anything touches Notion\nawait Actor.push_data(jobs)\nnotion_connector = actor_input.get('notionConnector')\nnotion_data_source_id = actor_input.get('notionDataSourceId')\nif notion_connector and notion_data_source_id:\n    try:\n        created = await sync_jobs_to_notion(\n            jobs,\n            connector_id=notion_connector,\n            data_source_id=notion_data_source_id,\n        )\n        Actor.log.info(f'✅ Wrote {created} jobs to Notion')\n    except Exception:\n        Actor.log.exception('Notion sync failed - dataset is unaffected')\nelse:\n    Actor.log.info('No Notion connector selected - dataset output only')\n```\n\nThe repository has the surrounding Actor lifecycle and job collection. The two guards that matter are both here: only call the sync when `notionConnector` and `notionDataSourceId` are both supplied, and never let it raise past the `try`.\n\n### Check tool responses as well as exceptions\n\nA successful network request can still carry a failed tool result. In the Python SDK the flag is `is_error`, snake case, not the `isError` that most existing MCP writing shows, because most of that writing is TypeScript. Exceptions cover transport and protocol failures; `is_error` covers everything else, and you have to check it after every call. Miss it and every write looks like it worked while nothing appears in Notion.\n\nDefine this helper in `src/notion_sync.py` before the batch-writing function:\n\n``` php\nfrom typing import Any, Optional\n\ndef _tool_error_text(result: Any) -> Optional[str]:\n    if not getattr(result, 'is_error', False):\n        return None\n    for block in getattr(result, 'content', None) or []:\n        text = getattr(block, 'text', None)\n        if text:\n            return text\n    return 'unknown error'\n```\n\nOnce the session is initialized and the rows are built, call `notion-create-pages` with the data source ID as parent. This excerpt from `sync_jobs_to_notion` uses `_chunk` and `PAGE_BATCH_SIZE` (20) from the same file; `CREATE_PAGES_TOOL` is `notion-create-pages`, and `created` starts at zero:\n\n```\nfor batch_no, batch in enumerate(_chunk(rows, PAGE_BATCH_SIZE), 1):\n    response = await session.call_tool(\n        CREATE_PAGES_TOOL,\n        arguments={\n            'parent': {'data_source_id': source_id},\n            'pages': batch,\n        },\n    )\n    error_text = _tool_error_text(response)\n    if error_text:\n        logger.error(f'Notion batch {batch_no} failed: {error_text}')\n        continue\n    created += len(batch)\n```\n\nLog the failed batches and count only the successful ones. And since the run can exit 0 with a broken sync, check the sync logs, not just the overall run status.\n\nStart with a small run and check a few pages against the dataset: job title, company, salary, destination. If your database only has a title column you'll get title-only pages, which is the same symptom as the empty-schema bug in this step with a far more boring cause. Add the optional columns before you expect to see values in them.\n\n## 5. Verify the result and measure the overhead\n\nTwo seconds and about 5% more compute. That's what the Notion write cost me.\n\nI ran the Actor over 20 companies at 512 MB, with and without the connector:\n\n|  | Runtime | Compute units | Jobs | Notion pages | \n|---|---|---|---|---|\n| Without connector | 38.7 s | 0.00537 | 50 | 0 | \n| With connector | 40.7 s | 0.00566 | 50 | 50 | \n\nBecause this Actor charges per result, that extra compute comes out of my margin. It doesn't raise the per-result price my users pay. At 5% I'll take that trade happily, but it's worth knowing which side of the ledger the overhead lands on before you ship a connector on a per-result Actor.\n\nThe 50 pages went out in three `notion-create-pages` calls, batched 20, 20, and 10. Those were the writes only; tool discovery and schema fetching were additional requests. One call per job would have meant 50 round trips and a much less pleasant table. It's a small comparison, so treat it as the overhead I measured rather than a guarantee for larger runs or other services.\n\nThe scrape output had the same shape in both runs: 20 companies, 50 jobs, 28 founders. The connector is optional. If nobody selects one, the Actor makes no MCP calls at all, and my existing users see exactly what they saw last month.\n\n## Before you schedule it, deal with duplicates\n\nOne thing I haven't solved yet. Every run appends new pages, so a daily schedule will re-add jobs that are already in the database.\n\nThere's no deduplication in the current implementation. If you want a persistent job tracker rather than a snapshot, comparing job URLs before writing is the next change to make, and I'd make it before setting up any schedule.\n\n## What I'd do differently\n\nI'd read from Notion, not just write to it. Right now the filters live in the Actor input. It'd be better to keep a Notion database of the batches, industries, and locations I care about, have the Actor read its own task list at the start of a run, and write results back. A loop instead of a one-way pipe. The connector already permits it; I just haven't built it.\n\nI'd also like to try two connectors on one Actor: Notion for the archive, Slack for a message when a job matches a saved search. The input schema accepts an array of connector IDs, with one MCP session per connector.\n\n## Reuse the Apify MCP connector pattern in another Actor\n\nFor a different destination, keep the same order: declare the tools, connect and save their descriptions, inspect the destination, map your results, and write only once the dataset is safe.\n\nAnother service will have its own connector, its own tool names, and its own payload format. Which is exactly why the discovery step in step 2 is worth doing first. It hands you those requirements up front instead of making you reverse-engineer them from error messages with `{propertyKeys}` in them.\n\n## FAQ\n\n### Can I add a connector to any existing Actor?\n\nThe Actor has to declare the connector input and contain code that calls it. For this scraper, select Notion and supply `notionDataSourceId`. Adding a connector in your account settings alone doesn't make an unrelated Actor write to Notion.\n\n### Can the Actor see my Notion token?\n\nNo. It authenticates to the Apify MCP proxy with its own run token, and the proxy adds the Notion credential server-side. The connector session ends with the run.\n\n### Can I restrict what the Actor can do?\n\nYes. Access has to satisfy the service's authorization permissions, any connector-level tool allowlist, and the Actor's `mcpServers[].tools` declaration. A tool allowlist limits operations, while the upstream service controls which content those operations can reach.\n\n### Can I develop this locally?\n\nNot really. `ACTOR_MCP_CONNECTOR_BASE_URL` only exists in a platform run. I test row building and response parsing locally, then use a dev build to verify authorization and real tool calls.\n\n### Which SDK version do I need?\n\n`mcp` 2.x for Python, which pulls `httpx2` rather than `httpx`. The 1.x API differs in both the transport function's name and its signature.\n\n### Is this the Apify MCP server?\n\nNo. Here the Actor calls Notion through an outbound MCP connector. The Apify [MCP server](https://docs.apify.com/mcp) is the other direction: it lets external AI clients call Actors.", "url": "https://wpnews.pro/news/i-gave-my-yc-jobs-scraper-write-access-to-notion-without-ever-holding-a-notion", "canonical_source": "https://blog.apify.com/apify-mcp-connectors-notion/", "published_at": "2026-11-16 00:00:00+00:00", "updated_at": "2026-11-16 13:21:50.984623+00:00", "lang": "en", "topics": ["ai-agents", "agent-protocols", "ai-tools", "developer-tools"], "entities": ["Apify", "Notion", "Artem Lazarev", "Y Combinator", "Model Context Protocol", "Apify MCP connectors"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/i-gave-my-yc-jobs-scraper-write-access-to-notion-without-ever-holding-a-notion", "markdown": "https://wpnews.pro/news/i-gave-my-yc-jobs-scraper-write-access-to-notion-without-ever-holding-a-notion.md", "text": "https://wpnews.pro/news/i-gave-my-yc-jobs-scraper-write-access-to-notion-without-ever-holding-a-notion.txt", "jsonld": "https://wpnews.pro/news/i-gave-my-yc-jobs-scraper-write-access-to-notion-without-ever-holding-a-notion.jsonld"}}