How to Automate Instagram Reels to Notion via MCP

Managing short-form video content across multiple campaigns often turns into an administrative nightmare. Your marketing team publishes dozens of public Reels, short video posts, and IGTV clips every month. Everything looks great on Instagram, but as soon as someone asks to archive these assets into a centralized brand library or content calendar, the entire operation grinds to a halt.

Suddenly, you are forced to rely on shady, ad-heavy download websites that fail half the time, paste individual links into manual file converters, or copy caption text into spreadsheets by hand. Even when you do manage to extract a direct video file URL from Instagram, that URL expires within hours due to Instagram's content delivery network (CDN) session restrictions.

What if you could automatically extract high-quality Instagram video files, store them permanently, and stream that structured data straight into Notion in real time?

With Instagram Video and Reel Downloader, the Notion Uploader Actor, and Apify Model Context Protocol (MCP) connectors, you can build a zero-maintenance, automated pipeline. This guide walks you through setting up an automated Instagram-to-Notion video content calendar that automatically syncs dataset outputs upon run completion without requiring manual CSV exports or fragile custom backend glue code.

The content archiving nightmare

Picture this scenario. You are a creative organization, and your creative team just finished a quarter-long influencer campaign. Thirty public Instagram Reels and video posts were published. Your client or department head wants every asset logged inside Notion with direct video links, preview thumbnails, shortcodes, captions, and publishing dates for future repurposing.

The traditional approach to this task usually follows one of two painful paths:

1. The manual downloader route: A team member spends hours copying Instagram links, pasting them into third-party downloader sites, closing popup ads, downloading .mp4 files locally, uploading those files into Google Drive or Notion, and typing metadata by hand. This process consumes dozens of work hours, produces inconsistent video resolutions, and risks downloading malware.
2. The legacy scraping route: A developer sets up a web scraper to pull Instagram data. The scraper runs for 10 minutes, completes its execution, and dumps a static JSON or CSV file to cloud storage. A developer then has to write custom webhooks or cron scripts to parse that output file, format the payload, and send REST API requests to Notion. If any record fails or if the script breaks mid-transit, debugging becomes a headache.

flowchart LR
    A["Scraper / Web Downloader"] --> B["CSV / JSON Export"]
    B --> C["Custom Glue Script / Manual Upload"]
    C --> D["Notion Database"]

Neither approach is ideal for growing teams or production workflows. Legacy scraping forces you to write custom integration pipelines to move data downstream. Meanwhile, manual downloading fails to scale beyond a handful of links.

Apify Actor integrations and Apify MCP connectors solve this problem seamlessly. Rather than manually writing custom export scripts or handling fragile API glue, you can attach the supported Notion Uploader Actor directly to your extraction workflow inside Apify Console.

flowchart LR
    A["Instagram Reels"] --> B["Instagram Video and Reel Downloader"]
    B -- On Run Succeeded --> C["Notion Uploader Actor Integration"]
    C -- Apify MCP Connector / API Key --> D["Notion Content Calendar"]

Once Instagram Video and Reel Downloader finishes extracting video assets and storing permanent .mp4 file links in Apify Key-Value Store, Apify automatically executes the Notion Uploader integration. Notion Uploader connects securely to your Notion workspace using an Apify MCP connector (configured in Apify Console under Settings → Integrations → MCP connectors) or a Notion API key, mapping fields and creating structured database rows automatically.

The pipeline architecture: how MCP connectors change the game

To understand why this architecture is so powerful, let's examine what happens under the hood during an automated run.

flowchart TD
    subgraph APIFY["APIFY PLATFORM"]
        A["Instagram /reel/ URLs"] --> B["Dual-Path Extraction Engine"]
        B --> C["Apify Key-Value Store<br/>(Permanent Video URL)"]
        B --> D["Apify Dataset<br/>(Structured Metadata)"]
    end

    D -- On Run Succeeded --> E["Notion Uploader Actor<br/>(filip_cicvarek/notion-uploader)"]
    E -- Apify MCP Connector / API Key --> F["Notion Content Calendar<br/>(Automated Database Rows)"]

1. Dual-path extraction engine

Instagram does not provide direct, permanent video download links through a simple public REST API. Furthermore, different post types behave differently:

• Some standard post pages expose media tags within initial static HTML.
• Complex Reel pages render content dynamically via JavaScript, obscuring video source URLs behind client-side network calls.

Instagram Video and Reel Downloader handles this seamlessly using a dual-path architecture. It first attempts a lightweight static HTTP request to extract the media link instantly. If the target page requires dynamic execution, the Actor automatically falls back to a browser session to capture media delivery requests.

2. Solving CDN URL expiration via Key-Value Store

Direct video URLs returned straight from Instagram's servers (*.cdninstagram.com or *.fbcdn.net) are session-bound and expire after a short period. If you paste a raw CDN video link into Notion, the video will stop playing within 24 to 48 hours.

To solve this, Instagram Video and Reel Downloader includes a storeVideoFiles configuration option in Apify Console. When set to true, the Actor streams the raw .mp4 file directly into Apify Key-Value Store during the run. This generates a permanent, publicly accessible URL (videoPublicUrl) that Notion can embed reliably forever.

3. Automated dataset push via Notion Uploader and MCP connectors

Model Context Protocol (MCP) is an open standard that allows tools and AI systems to exchange context and perform actions securely across application boundaries. In the Apify ecosystem, MCP connectors allow Actors like Notion Uploader to communicate directly with external services - such as Notion, HubSpot, Google Sheets, or Slack.

By configuring an Actor Integration on Instagram Video and Reel Downloader set to trigger on Run succeeded, Apify automatically hands off the generated dataset to Notion Uploader. Notion Uploader reads the structured items and uses the configured Notion MCP connector (or Notion API key) to map and upsert rows directly into your Notion database.

4. Zero-trust token security and governance

When connecting third-party services to web automations, storing API tokens in raw scripts or public Actor inputs poses severe security risks. Apify handles MCP authentication via OAuth 2.0 proxies managed centrally inside Apify Console under Settings → Integrations → MCP connectors.

Your Notion authorization token is never exposed in plain text, never saved in Actor dataset output, and never shared with the underlying script environment. The Apify platform handles identity verification and permission scope tokens securely behind the scenes.

Step 1: Setting up the Notion database

Before configuring the Actor, you need a designated Notion database structured to store video metadata and file references.

1. Open your Notion workspace and create a new database page (select Full page database or Inline database).
2. Name your database Instagram Content Calendar.
3. Configure the database properties to match the schema exported by Instagram Video and Reel Downloader:

Property Name	Notion Property Type	Purpose / Payload Source
Title	Title	Stores post caption snippet or title (title / description)
Instagram Link	URL	Direct link to original Instagram post (canonicalUrl)
Direct Video Link	URL	Permanent Apify storage link (videoPublicUrl)
Thumbnail	Files & media (or URL)	Preview thumbnail image (thumbnailUrl)
Shortcode	Text	Instagram unique ID (shortcode)
Media Type	Select	Post type (reel, post, or tv)
Fetch Date	Date	Timestamp of processing (fetchedAt)
Status	Status / Select	Processing result (ready or error)

erDiagram
    INSTAGRAM_CONTENT_CALENDAR {
        string Title "Summer Campaign Teaser"
        string Instagram_Link "instagram.com/reel/C123abc/"
        string Direct_Video_Link "api.apify.com/.../video-c123.mp4"
        string Media_Type "reel"
        string Status "ready"
    }

Ensure your Notion database view is set up to display URL and media properties clearly so your creative team can preview videos directly within the calendar workspace.

Step 2: Configuring Instagram Video and Reel Downloader

With your Notion database ready, navigate to Instagram Video and Reel Downloader on Apify Store.

Click Try for free or open the Actor inside Apify Console. Select the Input tab to configure your run.

Input JSON configuration

To ensure video URLs remain active inside Notion indefinitely, you must set storeVideoFiles to true. This instructs the Actor to download the binary media file into the Apify Key-Value Store and produce the videoPublicUrl parameter.

Here is an ideal production configuration snippet:

{
  "startUrls": [
    { "url": "https://www.instagram.com/reel/C8XyZ123abc/" },
    { "url": "https://www.instagram.com/p/C9AbC456def/" },
    { "url": "https://www.instagram.com/reel/C-Ghi789jkl/" }
  ],
  "storeVideoFiles": true,
  "storeThumbnailFiles": true,
  "includePageHtml": false,
  "filenamePrefix": "notion-archive-2026",
  "maxConcurrency": 2,
  "maxRequestRetries": 2,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Key configuration settings explained

• startUrls: An array of target public Instagram URLs. Supports /reel/, /p/, and /tv/ paths.
• storeVideoFiles: Set to true. This generates a permanent videoPublicUrl host link on api.apify.com, avoiding expired CDN link errors inside Notion.
• storeThumbnailFiles: Set to true if you want stored key-value records for thumbnail images as well.
• filenamePrefix: A custom string prepended to all stored files inside Apify storage (e.g., notion-archive-2026).
• maxConcurrency: Set to 2 or 3. Instagram actively monitors aggressive parallel scraping. Keeping concurrency low ensures reliable extraction without triggering rate limits.
• proxyConfiguration: Enabling Apify Proxy distributes requests across residential or datacenter IP pools, preventing unexpected block screens.

---

Step 3: Wiring the Notion Uploader integration in Apify Console

Once your input JSON is defined for Instagram Video and Reel Downloader, you attach the Notion Uploader Actor integration directly to the run configuration inside Apify Console.

1. Creating your Notion MCP connector (or API key)

Before attaching the integration, establish your connection to Notion inside Apify Console:

1. In Apify Console, open Settings → API & Integrations → MCP connectors.
2. Click Add connector and select Notion.
3. Complete the one-click OAuth authorization window to grant Apify access to your Notion workspace and database.
4. Apify Console generates a secure connector ID (e.g. mcp-connector-...) that allows Actors to interact with Notion with your permissions, without ever exposing raw private tokens.

(Alternative: You can also use a classic internal integration secret starting with ntn_ created at notion.so/profile/integrations. Be sure to invite your integration to the Notion database via *••• → Connections*).

flowchart LR
    A["Apify Console Settings"] --> B["MCP Connectors"]
    B --> C["Add Notion Connector (OAuth)"]
    C --> D["Secure Connector Session ID"]

2. Adding the Notion Uploader integration to your Actor

With your Notion MCP connector ready, wire the integration to Instagram Video and Reel Downloader:

1. Open Instagram Video and Reel Downloader in Apify Console.
2. Select the Integrations tab located in the navigation panel below the Actor title.
3. Click Add integration. Under Suggested for this Actor, click Notion Uploader (filip_cicvarek/notion-uploader). (Note: Apify Console also lists third-party integration routes like Make and Zapier under "Integrate with third-party tools", but Notion Uploader provides the direct, native Apify Actor integration path).
4. Set Start when to Run succeeded. This ensures Notion Uploader fires automatically the moment your Instagram extraction run completes cleanly.

3. Mapping fields and configuring Notion Uploader input

Under the Actor input section for the Notion Uploader integration, configure the target database and field mapping:

1. Notion connector: Select your authorized Notion MCP connector from the dropdown list (or paste your notionApiKey).
2. Notion database: Paste your Notion database URL or ID (notionDatabaseId).
3. Explicit field mapping (dataMapping): Map the dataset output fields from Instagram Video and Reel Downloader to your Notion database properties:

{
  "Title": "description",
  "Instagram Link": "canonicalUrl",
  "Direct Video Link": "videoPublicUrl",
  "Thumbnail": "thumbnailUrl",
  "Shortcode": "shortcode",
  "Media Type": "mediaType",
  "Fetch Date": "fetchedAt"
}

1. Duplicate handling (rerun safety): Set Dedupe mode (dedupeMode) to upsert and set Key property (keyProperty) to Instagram Link (or Shortcode). This guarantees that re-running the Actor with previously processed URLs will update existing database rows instead of creating duplicate entries.

Click Save integration. The integration is now active and bound to your Actor task.

Step 4: Executing the run and verifying the content calendar

With the input parameters set and the Notion Uploader integration saved, click the Start button in the top-right corner of Apify Console.

Watching automated workflow execution

As Instagram Video and Reel Downloader runs, you can monitor the progress through the Log tab:

1. The Actor extracts public Instagram video posts, Reels, and IGTV links specified in startUrls.
2. For each URL, it resolves media endpoints and streams binary .mp4 files into Apify Key-Value Store, generating permanent videoPublicUrl host links.
3. Integration handoff: When the extraction run finishes successfully (Run succeeded), Apify immediately launches Notion Uploader (filip_cicvarek/notion-uploader), passing the run's default dataset ID automatically.
4. Notion Database update: Notion Uploader uses your Notion MCP connector to read the dataset items, validate properties against your database schema, apply upsert deduplication, and populate your Instagram Content Calendar in Notion.

sequenceDiagram
    autonumber
    participant Downloader as Instagram Video Downloader
    participant KVS as Key-Value Store
    participant Integration as Notion Uploader Integration
    participant Notion as Notion Database

    Note over Downloader: Downloader starts execution
    Downloader->>KVS: Extracts Reel & uploads .mp4 file
    Note over Downloader: Run completes (Status: SUCCESS)
    Downloader->>Integration: Triggers Notion Uploader automatically
    Integration->>Notion: Reads dataset & upserts database rows
    Note over Notion: Content calendar fully updated!

If an invalid or private URL is encountered, the extraction Actor records a structured dataset item containing an errorCode (such as NO_VIDEO_URL) and errorMessage. Notion Uploader writes an error status row into Notion, maintaining a complete audit log without breaking the pipeline execution.

---

Extending the workflow with API triggers and scheduling

Building a one-off run inside Apify Console is great for testing, but real content operations require automated execution. You can automate this pipeline using code triggers or scheduled jobs.

Programmatic execution via JavaScript / TypeScript

You can trigger the integrated pipeline programmatically using the official apify-client SDK in Node.js or TypeScript by invoking your saved task (which includes the Notion Uploader integration):

import { ApifyClient } from 'apify-client';

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

// Define input parameters with video storage enabled
const input = {
  startUrls: [
    { url: 'https://www.instagram.com/reel/C8XyZ123abc/' },
    { url: 'https://www.instagram.com/reel/C9AbC456def/' }
  ],
  storeVideoFiles: true,
  storeThumbnailFiles: true,
  filenamePrefix: 'weekly-content-sync',
  maxConcurrency: 2,
  proxyConfiguration: {
    useApifyProxy: true
  }
};

async function runInstagramSync() {
  console.log('Starting Instagram to Notion sync workflow...');

  // Call the saved task (or Actor). Configured integrations run automatically on completion.
  const run = await client.task('YOUR_SAVED_TASK_ID').call(input);

  console.log(`Run completed! View dataset at: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
  console.log('Notion Uploader integration triggered automatically.');
}

runInstagramSync();

Programmatic execution via Python

If your infrastructure runs on Python, use apify-client to trigger the sync:

from apify_client import ApifyClient

# Initialize client
client = ApifyClient("YOUR_APIFY_API_TOKEN")

# Prepare input dictionary
run_input = {
    "startUrls": [
        {"url": "https://www.instagram.com/reel/C8XyZ123abc/"},
        {"url": "https://www.instagram.com/reel/C9AbC456def/"}
    ],
    "storeVideoFiles": True,
    "storeThumbnailFiles": True,
    "filenamePrefix": "python-content-sync",
    "maxConcurrency": 2,
    "proxyConfiguration": {
        "useApifyProxy": True
    }
}

# Run the saved task with Notion integration attached
print("Launching Instagram Video Downloader with Notion Uploader Integration...")
run = client.task("YOUR_SAVED_TASK_ID").call(task_input=run_input)

print(f"Workflow complete. Dataset ID: {run['defaultDatasetId']}")

Automated set-and-forget scheduling

To eliminate manual execution:

1. Save your input configuration and Notion Uploader integration inside Apify Console as a Saved Task (e.g., Instagram-to-Notion-Sync-Task).
2. Navigate to the Schedules tab in Apify Console and click Create schedule.
3. Link the schedule to your saved Actor task.
4. Set a cron cadence, such as every Friday at 5:00 PM (0 17 * * 5).

Every week, Apify will automatically run Instagram Video and Reel Downloader, extract new video links, upload permanent .mp4 binaries to Key-Value Store, and trigger Notion Uploader to push the assets into your Notion database.

Wrapping up

Relying on ad-ridden video download websites, manual file management, and fragile spreadsheet uploads is no longer necessary for modern media operations.

By combining the extraction capabilities of Instagram Video and Reel Downloader with the Notion Uploader Actor and Apify MCP connectors, you can build a seamless content archiving pipeline. Permanent video hosting via Apify Key-Value Store eliminates broken CDN links, while automated Actor integrations push structured data straight into Notion without requiring custom backend glue code.

Ready to automate your social media asset pipeline?

Try Instagram Video and Reel Downloader on Apify Store today, connect your Notion workspace via Notion Uploader, and build your automated content calendar in minutes.