January 21, 2026

Notion to Google Drive, backups you can trust

Lisa Granqvist Partner Workflow Automation Expert

Get a free AI assessment → ⬇️ Use template

You don’t notice how fragile Notion feels until you need a restore. A key database gets changed, a view is overwritten, someone deletes a property, and now you’re digging through “undo” history hoping it’s enough.

This Notion Drive backups automation hits ops managers and small teams first because they live in databases all day. But agency owners running client workspaces and marketers tracking campaigns in Notion feel the same anxiety when the “source of truth” has no real backup.

This workflow copies your Notion databases into Google Drive, organizes them into clean folders, deletes older backups based on retention rules, and pings you on Telegram so you can actually relax. You’ll see what it does, what you need, and how it fits into a real week of work.

How This Automation Works

See how this solves the problem:

n8n Workflow Template: Notion to Google Drive, backups you can trust

Click to explore

flowchart LR

    subgraph sg0["Manual Start Flow"]
        direction LR
        n0@{ icon: "mdi:play-circle", form: "rounded", label: "Manual Start Trigger", pos: "b", h: 48 }
        n1@{ icon: "mdi:swap-vertical", form: "rounded", label: "Backup Configurator", pos: "b", h: 48 }
        n2@{ icon: "mdi:cog", form: "rounded", label: "Generate Drive Folder", pos: "b", h: 48 }
        n3["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/notion.dark.svg' width='40' height='40' /></div><br/>Retrieve Notion Databases"]
        n4["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Initialize Backup Tracker"]
        n5@{ icon: "mdi:swap-vertical", form: "rounded", label: "Iterate Databases Batch", pos: "b", h: 48 }
        n6["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/notion.dark.svg' width='40' height='40' /></div><br/>Fetch Database Pages"]
        n7["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Build Backup File"]
        n8@{ icon: "mdi:cog", form: "rounded", label: "Upload Backup Archive", pos: "b", h: 48 }
        n9["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Assemble Backup Metadata"]
        n10@{ icon: "mdi:cog", form: "rounded", label: "Send Metadata File", pos: "b", h: 48 }
        n11@{ icon: "mdi:swap-horizontal", form: "rounded", label: "Cleanup Decision", pos: "b", h: 48 }
        n12@{ icon: "mdi:cog", form: "rounded", label: "List Previous Backups", pos: "b", h: 48 }
        n13["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Filter Aged Backups"]
        n14@{ icon: "mdi:swap-horizontal", form: "rounded", label: "Folder Deletion Check", pos: "b", h: 48 }
        n15@{ icon: "mdi:cog", form: "rounded", label: "Remove Old Backup", pos: "b", h: 48 }
        n16["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Compose Notification"]
        n17["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/telegram.svg' width='40' height='40' /></div><br/>Dispatch Telegram Alert"]
        n14 --> n15
        n14 --> n16
        n5 --> n9
        n5 --> n6
        n0 --> n1
        n11 --> n12
        n11 --> n16
        n10 --> n11
        n12 --> n13
        n15 --> n16
        n9 --> n10
        n3 --> n4
        n7 --> n8
        n13 --> n14
        n6 --> n7
        n8 --> n5
        n16 --> n17
        n4 --> n5
        n2 --> n3
        n1 --> n2
    end

    %% Styling
    classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
    classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
    classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
    classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
    classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
    classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
    classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    classDef disabled stroke-dasharray: 5 5,opacity: 0.5
    class n0 trigger
    class n11,n14 decision
    class n3,n6 database
    class n4,n7,n9,n13,n16 code
    classDef customIcon fill:none,stroke:none
    class n3,n4,n6,n7,n9,n13,n16,n17 customIcon

The Challenge: Notion Isn’t a Backup System

Notion is brilliant for running projects, storing client assets, tracking content, and keeping databases that power day-to-day decisions. But it’s also easy to accidentally break. A “quick cleanup” turns into a missing column. A filter is changed and suddenly someone thinks rows disappeared. Even when nothing goes wrong, teams still ask the same question: “If this workspace got messed up today, how fast could we restore it?” Honestly, most people don’t have a good answer because manual exports are annoying, inconsistent, and easy to forget.

It adds up fast. Here’s where it breaks down in real life.

Manual Notion exports are a “someday” task, so backups tend to be missing right when you need them.
Files end up scattered in Drive with random names, which makes restore day feel like detective work.
Teams back up “important databases” but forget the supporting ones, so you never have a complete snapshot.
Without retention rules, old backups pile up and nobody knows which folder is safe to delete.

The Fix: Automated Notion Database Backups in Drive

This workflow creates a repeatable backup routine for Notion that does not depend on someone remembering. It starts by generating a fresh Google Drive folder for the backup run (so each run stays clean and self-contained). Then it pulls a list of your Notion databases and loops through them in batches, fetching pages for each database and compiling the content into a backup file. Once the archive is built, it uploads the backup to Drive and also uploads a small metadata file that acts like a receipt (what was backed up, when, and where it landed). After that, it checks your retention settings, finds older backup folders, and deletes the ones that are past your cutoff. Finally, you get a Telegram message confirming the run, so you’re never guessing.

The workflow kicks off from a manual trigger in n8n (you can later schedule it). From there, Notion data is collected and packaged, Google Drive stores the archive and metadata, and Telegram confirms success or flags cleanup actions. No more “I think we backed it up last month.”

What Changes: Before vs. After

What This Eliminates

Impact You’ll See

Remembering to export databases manually and naming files consistently.
Hunting through Drive to figure out which backups are complete.
Letting old backup folders accumulate until storage becomes a problem.
Quiet failures where “no news” hides the fact nothing ran.

Most teams get about 2 hours back each month from skipped manual exports.
Cleaner restores because each run has its own Drive folder and a metadata receipt.
Less risk from accidental Notion edits because you always have recent snapshots.
More predictable storage since aged backups are removed automatically.
Faster confidence checks because Telegram tells you it worked.

Real-World Impact

Say you back up 10 Notion databases each week. Manually, exporting, naming, and filing each one is maybe 10 minutes per database, plus another 20 minutes to double-check you didn’t miss anything, so you’re spending about 2 hours weekly. With this workflow, you kick it off (or schedule it), wait for Drive uploads to finish, and you’re done in about 5 minutes of active effort. That’s roughly an afternoon saved every month, and your backups are actually consistent.

Requirements

n8n instance (try n8n Cloud free)
Self-hosting option if you prefer (Hostinger works well)
Notion for database access and exports.
Google Drive to store backups and metadata files.
Telegram bot token + chat ID (get them from BotFather and your Telegram chat).

Skill level: Intermediate. You’ll connect credentials and paste a few IDs (Notion integration access, Drive folder ID, Telegram chat ID).

Need help implementing this? Talk to an automation expert (free 15-minute consultation).

The Workflow Flow

Manual run starts the backup. You click “Execute” in n8n (many teams later swap this for a schedule), and a configuration step sets things like naming and retention behavior.

A fresh Drive folder is created. Google Drive generates a new “backup run” folder so every backup stays grouped, which makes restores far less painful.

Notion databases are retrieved and processed in batches. The workflow pulls your database list, loops through each one, fetches its pages, and builds a backup archive plus a small metadata file that summarizes what happened.

Files upload, then cleanup runs, then you get a Telegram message. The archive and metadata are saved to Drive, older backup folders are listed and filtered based on age, and the workflow deletes what no longer fits your retention rules. A Telegram alert closes the loop so you don’t have to check Drive manually.

You can easily modify retention rules to keep backups longer, or change the folder naming to match your client/project structure. See the full implementation guide below for customization options.

Step-by-Step Implementation Guide

Step 1: Configure the Manual Trigger

This workflow starts manually, making it ideal for on-demand backups while you validate configuration.

Add the Manual Start Trigger node as the trigger to initiate the workflow on demand.
Leave all parameters at default since Manual Start Trigger has no required fields.

Step 2: Connect Notion and Google Drive

These nodes fetch Notion databases and create a Google Drive backup folder for storage.

Open Generate Drive Folder and set Name to =Notion_Backup_V2_{{ $now.format('yyyy-MM-dd_HHmmss') }}.
In Generate Drive Folder, set Folder ID to ={{ $json.parent_folder_id }} and keep Resource as folder.
Open Retrieve Notion Databases and set Resource to database, Operation to getAll, and Return All to true.
Credential Required: Connect your googleDriveOAuth2Api credentials in Generate Drive Folder (and reuse the same credentials in all Google Drive nodes).
Credential Required: Connect your notionApi credentials in Retrieve Notion Databases and Fetch Database Pages.

⚠️ Common Pitfall: The parent folder ID comes from Backup Configurator. If it is left as YOUR_GOOGLE_DRIVE_PARENT_FOLDER_ID, folder creation will fail.

Step 3: Set Up Backup Configuration and Tracking

These nodes define backup preferences and prepare the database list for batch processing.

Open Backup Configurator and set backup_format to json.
Set retention_days to 5 and enable_cleanup to true.
Set parent_folder_id to your Google Drive parent folder ID and telegram_chat_id to your target Telegram chat ID.
Keep Initialize Backup Tracker as-is; it uses Generate Drive Folder to attach folder metadata for each database.
In Iterate Databases Batch, keep defaults; it controls the loop over each Notion database.

Step 4: Configure Backup File Generation and Upload

This section retrieves Notion pages, builds a JSON archive, and uploads each backup into the Drive folder.

In Fetch Database Pages, set Resource to databasePage, Operation to getAll, Return All to true, and Database ID to ={{ $json.database_id }}.
Leave Build Backup File unchanged; it composes JSON content and generates a binary file for upload.
In Upload Backup Archive, set Name to ={{ $json.file_name }} and Folder ID to ={{ $('Generate Drive Folder').first().json.id }}.
Understand the flow: Iterate Databases Batch sends each batch to Fetch Database Pages, then Build Backup File, then Upload Backup Archive, and loops back to Iterate Databases Batch until complete.

Step 5: Configure Metadata, Cleanup Logic, and Notifications

These nodes assemble metadata, optionally delete old backups, and send a Telegram alert.

In Assemble Backup Metadata, keep defaults; it summarizes backup statistics and creates backup_metadata.json.
In Send Metadata File, set Name to backup_metadata.json and Folder ID to ={{ $('Generate Drive Folder').first().json.id }}.
In Cleanup Decision, confirm the condition checks ={{ $('Backup Configurator').first().json.enable_cleanup }} is true.
In List Previous Backups, set Resource to fileFolder, Return All to true, and Query String to Notion_Backup_.
In Folder Deletion Check, ensure the condition checks ={{ $json.has_folders }} equals true before deleting.
In Remove Old Backup, keep Operation as deleteFolder and the folder ID value as ={{ $json.id }}.
In Dispatch Telegram Alert, set Text to ={{ $json.message }} and Chat ID to ={{ $json.chat_id }}.
Credential Required: Connect your telegramApi credentials in Dispatch Telegram Alert.

Google Drive credentials are used by multiple nodes: Generate Drive Folder, Upload Backup Archive, Send Metadata File, List Previous Backups, and Remove Old Backup. Use the same googleDriveOAuth2Api account for consistency.

Step 6: Test and Activate Your Workflow

Validate the full backup cycle before enabling it for production use.

Click Execute Workflow on Manual Start Trigger to run a full backup.
Confirm a new Google Drive folder named like Notion_Backup_V2_YYYY-MM-DD_HHmmss is created and contains JSON backup files.
Verify backup_metadata.json is uploaded to the same folder.
Check Telegram for the message sent by Dispatch Telegram Alert with the summary and backup folder link.
When satisfied, toggle the workflow to Active for production use.

🔒

Unlock Full Step-by-Step Guide

Get the complete implementation guide + downloadable template

Watch Out For

Notion credentials and sharing are the usual culprit. If a database won’t export, confirm it was shared with your Notion integration in Notion’s “Connections” settings.
If you’re using Wait nodes or external rendering, processing times vary. Bump up the wait duration if downstream nodes fail on empty responses.
Telegram notifications fail silently when the chat ID is wrong. Check the Telegram node execution output first, then regenerate your bot token if needed.

Common Questions

How quickly can I implement this Notion Drive backups automation?

About 30 minutes if your Notion, Drive, and Telegram accounts are ready.

Can non-technical teams implement this backup automation?

Yes. You won’t write code, but you will copy a few IDs and connect credentials in n8n.

Is n8n free to use for this Notion Drive backups workflow?

Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in Telegram (free) and standard Notion/Google account costs.

Where can I host n8n to run this automation?

Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.

How do I adapt this Notion Drive backups solution to my specific challenges?

Start with the “Backup Configurator” step because that’s where naming and retention behavior are set. You can also adjust the cleanup logic by changing the “Cleanup Decision” and “Folder Deletion Check” conditions, which is useful if you want to keep monthly backups longer than weekly ones. If your Drive needs client-specific folders, tweak “Generate Drive Folder” to nest backups under a client directory. Many teams also customize the Telegram message in “Compose Notification” so it includes the Drive folder link and a count of databases backed up.

Why is my Notion connection failing in this workflow?

Usually the databases were never shared with the Notion integration, so n8n can’t “see” them. Recheck the integration in Notion, then confirm the right workspace is selected in your Notion credential. If it fails partway through, it can also be rate limiting from pulling lots of pages at once, so reduce batch size in the loop and run it again.

What’s the capacity of this Notion Drive backups solution?

In practice it scales to dozens of databases per run, and the main limit is how many Notion pages you’re pulling. On n8n Cloud Starter you can run a healthy number of executions per month for a single workspace, and higher plans handle more volume. If you self-host, there’s no execution cap, but your server and Notion’s API limits become the bottleneck. If you have very large databases, schedule backups during quiet hours and keep the batch size modest.

Is this Notion Drive backups automation better than using Zapier or Make?

Often, yes. This workflow uses looping, filtering, file building, and retention cleanup in one place, and that kind of logic gets expensive or awkward in simpler automation tools. n8n also gives you a self-hosting path, which is handy if you want unlimited runs and tighter control over data. Zapier or Make can still be fine for a lightweight “export one thing” use case, but the moment you need batched backups and cleanup, n8n tends to feel more practical. If you’re torn, Talk to an automation expert and we’ll map it to your volume and risk level.

Backups aren’t exciting. But the first time you need one, you’ll be glad this is running in the background, quietly doing the boring work for you.

Need Help Setting This Up?

Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.

Lisa Granqvist

Workflow Automation Expert

Expert in workflow automation and no-code tools.

{
"id": "",
"meta": {
"instanceId": "3fe6e281d7ed2c60a5e836234819fbaa1983d9025931f82e8325606c5ec507b0",
"templateId": null,
"templateCredsSetupCompleted": null
},
"name": "Automated Notion Backup Archive",
"tags": [],
"nodes": [
{
"id": "flowpast-topbar-10235",
"name": "Flowpast Branding",
"type": "n8n-nodes-base.stickyNote",
"position": [
0,
20
],
"parameters": {
"color": 7,
"width": 1365,
"height": 80,
"content": "## Flowpast.com | Automation Workflow Library\n**\ud83d\udcd6 Full tutorial & setup guide:** flowpast.com"
},
"typeVersion": 1
},
{
"id": "df9f37f5-d06d-44d5-8574-2ce1822791af",
"name": "Manual Start Trigger",
"type": "n8n-nodes-base.manualTrigger",
"position": [
1110,
120
],
"parameters": [],
"typeVersion": 1
},
{
"id": "6bd07d17-fa58-44ee-ac35-b4c733686434",
"name": "Backup Configurator",
"type": "n8n-nodes-base.set",
"position": [
835,
185
],
"parameters": {
"options": [],
"assignments": {
"assignments": [
{
"id": "backup-format",
"name": "backup_format",
"type": "string",
"value": "json"
},
{
"id": "retention-days",
"name": "retention_days",
"type": "number",
"value": 5
},
{
"id": "enable-cleanup",
"name": "enable_cleanup",
"type": "boolean",
"value": true
},
{
"id": "parent-folder-id",
"name": "parent_folder_id",
"type": "string",
"value": "YOUR_GOOGLE_DRIVE_PARENT_FOLDER_ID"
},
{
"id": "telegram-chat-id",
"name": "telegram_chat_id",
"type": "string",
"value": "YOUR_TELEGRAM_CHAT_ID"
}
]
}
},
"typeVersion": 3.4
},
{
"id": "fd6bafaa-3a25-4b54-8bff-c088f2e5aa8b",
"name": "Generate Drive Folder",
"type": "n8n-nodes-base.googleDrive",
"position": [
680,
150
],
"parameters": {
"name": "=Notion_Backup_V2_{{ $now.format('yyyy-MM-dd_HHmmss') }}",
"driveId": {
"__rl": true,
"mode": "list",
"value": "My Drive",
"cachedResultUrl": "https://drive.google.com/drive/my-drive",
"cachedResultName": "My Drive"
},
"options": [],
"folderId": {
"__rl": true,
"mode": "id",
"value": "={{ $json.parent_folder_id }}"
},
"resource": "folder"
},
"credentials": {
"googleDriveOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"executeOnce": true,
"typeVersion": 3
},
{
"id": "81915f5d-ba74-484f-b15e-dea36385e349",
"name": "Retrieve Notion Databases",
"type": "n8n-nodes-base.notion",
"position": [
390,
140
],
"parameters": {
"resource": "database",
"operation": "getAll",
"returnAll": true
},
"credentials": {
"notionApi": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.2
},
{
"id": "1c114eb9-55e2-49cd-9266-993e7eb79f2d",
"name": "Initialize Backup Tracker",
"type": "n8n-nodes-base.code",
"position": [
220,
350
],
"parameters": {
"jsCode": "// Initialize backup tracking\nconst databases = $input.all();\nconst backupStartTime = new Date().toISOString();\nconst folderId = $('Generate Drive Folder').first().json.id;\nconst folderName = $('Generate Drive Folder').first().json.name;\n\n// Prepare databases with tracking info\nconst processedDatabases = databases.map((item, index) => {\n  const db = item.json;\n  const dbName = db.title?.[0]?.plain_text || `Database_${index + 1}`;\n  \n  return {\n    json: {\n      database_id: db.id,\n      database_name: dbName,\n      database_title: db.title,\n      created_time: db.created_time,\n      last_edited_time: db.last_edited_time,\n      backup_folder_id: folderId,\n      backup_folder_name: folderName,\n      backup_start_time: backupStartTime,\n      index: index + 1,\n      total_databases: databases.length,\n      status: 'pending'\n    }\n  };\n});\n\nreturn processedDatabases;"
},
"typeVersion": 2
},
{
"id": "e92528b1-5f8d-4f4c-a796-823a22c4d32d",
"name": "Iterate Databases Batch",
"type": "n8n-nodes-base.splitInBatches",
"position": [
380,
335
],
"parameters": {
"options": {
"reset": false
}
},
"typeVersion": 3
},
{
"id": "f41e87bd-aecd-41dd-a015-162e0ba6a0c0",
"name": "Fetch Database Pages",
"type": "n8n-nodes-base.notion",
"position": [
675,
295
],
"parameters": {
"simple": false,
"options": [],
"resource": "databasePage",
"operation": "getAll",
"returnAll": true,
"databaseId": {
"__rl": true,
"mode": "id",
"value": "={{ $json.database_id }}"
}
},
"credentials": {
"notionApi": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.2,
"continueOnFail": true
},
{
"id": "fd168167-7255-4d14-8903-432f6e16219b",
"name": "Build Backup File",
"type": "n8n-nodes-base.code",
"position": [
840,
360
],
"parameters": {
"jsCode": "// Get database info from loop\nconst dbInfo = $('Iterate Databases Batch').first().json;\nconst dbName = dbInfo.database_name;\nconst dbId = dbInfo.database_id;\nconst backupTime = new Date().toISOString();\n\n// Check if pages were retrieved successfully\nconst pagesNode = $input.first();\nlet pages = [];\nlet status = 'success';\nlet errorMessage = null;\n\ntry {\n  if (pagesNode.error) {\n    status = 'error';\n    errorMessage = pagesNode.error.message || 'Unknown error';\n  } else {\n    pages = $input.all().map(item => item.json);\n  }\n} catch (error) {\n  status = 'error';\n  errorMessage = error.message;\n}\n\n// Create backup structure\nconst backup = {\n  metadata: {\n    database_id: dbId,\n    database_name: dbName,\n    database_title: dbInfo.database_title,\n    backup_timestamp: backupTime,\n    backup_date: new Date().toISOString().split('T')[0],\n    total_pages: pages.length,\n    created_time: dbInfo.created_time,\n    last_edited_time: dbInfo.last_edited_time,\n    backup_status: status,\n    error_message: errorMessage\n  },\n  pages: pages\n};\n\n// Create safe filename\nconst safeFileName = dbName.replace(/[^a-z0-9]/gi, '_').toLowerCase();\nconst timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];\nconst fileName = `${safeFileName}_${timestamp}.json`;\n\n// Convert to JSON and then to binary\nconst jsonContent = JSON.stringify(backup, null, 2);\nconst base64Content = Buffer.from(jsonContent, 'utf8').toString('base64');\n\nreturn {\n  json: {\n    database_name: dbName,\n    database_id: dbId,\n    file_name: fileName,\n    pages_count: pages.length,\n    backup_size_bytes: Buffer.byteLength(jsonContent, 'utf8'),\n    status: status,\n    error_message: errorMessage,\n    backup_timestamp: backupTime\n  },\n  binary: {\n    data: {\n      data: base64Content,\n      mimeType: 'application/json',\n      fileName: fileName\n    }\n  }\n};"
},
"typeVersion": 2,
"alwaysOutputData": true
},
{
"id": "c33cb193-4439-48d7-90cf-c894db4c4e95",
"name": "Upload Backup Archive",
"type": "n8n-nodes-base.googleDrive",
"position": [
705,
470
],
"parameters": {
"name": "={{ $json.file_name }}",
"driveId": {
"__rl": true,
"mode": "list",
"value": "My Drive"
},
"options": [],
"folderId": {
"__rl": true,
"mode": "id",
"value": "={{ $('Generate Drive Folder').first().json.id }}"
}
},
"credentials": {
"googleDriveOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 3
},
{
"id": "a70580ca-1883-4c3c-9276-8ca581754457",
"name": "Assemble Backup Metadata",
"type": "n8n-nodes-base.code",
"position": [
405,
525
],
"parameters": {
"jsCode": "// Collect all backup results\nconst allBackups = $input.all();\nconst config = $('Backup Configurator').first().json;\nconst folderInfo = $('Generate Drive Folder').first().json;\n\n// Calculate statistics\nconst successfulBackups = allBackups.filter(b => b.json.status === 'success');\nconst failedBackups = allBackups.filter(b => b.json.status === 'error');\nconst totalPages = successfulBackups.reduce((sum, b) => sum + b.json.pages_count, 0);\nconst totalSize = allBackups.reduce((sum, b) => sum + (b.json.backup_size_bytes || 0), 0);\n\n// Format size\nconst formatSize = (bytes) => {\n  if (bytes < 1024) return bytes + ' B';\n  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + ' KB';\n  return (bytes / (1024 * 1024)).toFixed(2) + ' MB';\n};\n\n// Create metadata\nconst metadata = {\n  backup_info: {\n    backup_date: new Date().toISOString().split('T')[0],\n    backup_timestamp: new Date().toISOString(),\n    folder_name: folderInfo.name,\n    folder_id: folderInfo.id,\n    folder_url: folderInfo.webViewLink\n  },\n  summary: {\n    total_databases: allBackups.length,\n    successful_backups: successfulBackups.length,\n    failed_backups: failedBackups.length,\n    total_pages_backed_up: totalPages,\n    total_size: formatSize(totalSize),\n    total_size_bytes: totalSize\n  },\n  successful_databases: successfulBackups.map(b => ({\n    name: b.json.database_name,\n    id: b.json.database_id,\n    pages_count: b.json.pages_count,\n    file_name: b.json.file_name,\n    size: formatSize(b.json.backup_size_bytes)\n  })),\n  failed_databases: failedBackups.map(b => ({\n    name: b.json.database_name,\n    id: b.json.database_id,\n    error: b.json.error_message\n  })),\n  configuration: {\n    retention_days: config.retention_days,\n    backup_format: config.backup_format,\n    cleanup_enabled: config.enable_cleanup\n  }\n};\n\n// Create metadata file\nconst metadataJson = JSON.stringify(metadata, null, 2);\nconst base64Metadata = Buffer.from(metadataJson, 'utf8').toString('base64');\n\nreturn {\n  json: {\n    ...metadata.summary,\n    folder_url: folderInfo.webViewLink,\n    successful_databases: successfulBackups.map(b => b.json.database_name),\n    failed_databases: failedBackups.map(b => b.json.database_name),\n    has_failures: failedBackups.length > 0\n  },\n  binary: {\n    data: {\n      data: base64Metadata,\n      mimeType: 'application/json',\n      fileName: 'backup_metadata.json'\n    }\n  }\n};"
},
"typeVersion": 2
},
{
"id": "aefb78d9-6495-44c9-af95-56b9cf95a538",
"name": "Send Metadata File",
"type": "n8n-nodes-base.googleDrive",
"position": [
245,
480
],
"parameters": {
"name": "backup_metadata.json",
"driveId": {
"__rl": true,
"mode": "list",
"value": "My Drive"
},
"options": [],
"folderId": {
"__rl": true,
"mode": "id",
"value": "={{ $('Generate Drive Folder').first().json.id }}"
}
},
"credentials": {
"googleDriveOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 3
},
{
"id": "026072e9-0525-4510-8c15-bbd9e2303d0e",
"name": "Cleanup Decision",
"type": "n8n-nodes-base.if",
"position": [
0,
535
],
"parameters": {
"options": [],
"conditions": {
"options": {
"version": 2,
"leftValue": "",
"caseSensitive": true,
"typeValidation": "strict"
},
"combinator": "and",
"conditions": [
{
"id": "cleanup-enabled",
"operator": {
"type": "boolean",
"operation": "true"
},
"leftValue": "={{ $('Backup Configurator').first().json.enable_cleanup }}",
"rightValue": true
}
]
}
},
"typeVersion": 2.2
},
{
"id": "fed62555-581b-4070-ac4a-fb691ee88673",
"name": "List Previous Backups",
"type": "n8n-nodes-base.googleDrive",
"position": [
230,
655
],
"parameters": {
"filter": {
"folderId": {
"mode": "list",
"value": "root",
"cachedResultName": "/ (Root folder)"
}
},
"options": [],
"resource": "fileFolder",
"returnAll": true,
"queryString": "Notion_Backup_"
},
"credentials": {
"googleDriveOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 3
},
{
"id": "814bf4bb-c1cb-4abc-b7f5-80c205836aad",
"name": "Filter Aged Backups",
"type": "n8n-nodes-base.code",
"position": [
375,
700
],
"parameters": {
"jsCode": "// Get retention days from config\nconst retentionDays = $('Backup Configurator').first().json.retention_days;\nconst currentFolderId = $('Generate Drive Folder').first().json.id;\n\n// Get all backup folders\nconst allFolders = $input.all();\n\n// Si no hay carpetas, retornar false flag\nif (!allFolders || allFolders.length === 0) {\n  console.log('No folders received from previous node');\n  return [{\n    json: {\n      has_folders: false,\n      message: 'No backup folders found'\n    }\n  }];\n}\n\n// Calculate cutoff date\nconst cutoffDate = new Date();\ncutoffDate.setDate(cutoffDate.getDate() - retentionDays);\n\nconsole.log('=== DEBUG FILTER ===');\nconsole.log('Retention days:', retentionDays);\nconsole.log('Cutoff date:', cutoffDate.toISOString());\nconsole.log('Current folder ID:', currentFolderId);\nconsole.log('Total folders found:', allFolders.length);\n\n// Filter folders older than retention period\nconst foldersToDelete = allFolders.filter(item => {\n  const folder = item.json;\n  \n  // Don't delete the current backup\n  if (folder.id === currentFolderId) {\n    console.log('Skipping current backup:', folder.name);\n    return false;\n  }\n  \n  // Parse folder name to get date\n  // Match both formats: Notion_Backup_2025-01-15 and Notion_Backup_V2_2025-01-15\n  const match = folder.name.match(/Notion_Backup(?:_V\\d+)?_(\\d{4}-\\d{2}-\\d{2})/);\n  \n  if (!match) {\n    console.log('No date match for:', folder.name);\n    return false;\n  }\n  \n  const folderDate = new Date(match[1]);\n  const shouldDelete = folderDate < cutoffDate;\n  \n  console.log(`Folder: ${folder.name}, Date: ${match[1]}, Should delete: ${shouldDelete}`);\n  \n  return shouldDelete;\n});\n\nconsole.log('Folders to delete:', foldersToDelete.length);\n\n// Si no hay carpetas para eliminar, retornar false flag\nif (foldersToDelete.length === 0) {\n  console.log('No folders to delete');\n  return [{\n    json: {\n      has_folders: false,\n      message: 'No old folders to delete'\n    }\n  }];\n}\n\n// Si hay carpetas para eliminar, agregarles el flag\nreturn foldersToDelete.map(item => ({\n  json: {\n    ...item.json,\n    has_folders: true\n  }\n}));"
},
"typeVersion": 2,
"alwaysOutputData": false
},
{
"id": "636274ad-9ffb-4113-a13d-a62a5be7c6d9",
"name": "Folder Deletion Check",
"type": "n8n-nodes-base.if",
"position": [
660,
650
],
"parameters": {
"options": [],
"conditions": {
"options": {
"version": 3,
"leftValue": "",
"caseSensitive": true,
"typeValidation": "strict"
},
"combinator": "and",
"conditions": [
{
"id": "d7bbc942-9e79-4e2c-968d-ac83d2cc6e64",
"operator": {
"type": "boolean",
"operation": "equals"
},
"leftValue": "={{ $json.has_folders }}",
"rightValue": true
}
]
}
},
"typeVersion": 2.3
},
{
"id": "208eecf9-6cff-42db-a8b4-d19817ae1bbb",
"name": "Remove Old Backup",
"type": "n8n-nodes-base.googleDrive",
"position": [
835,
715
],
"parameters": {
"options": [],
"resource": "folder",
"operation": "deleteFolder",
"folderNoRootId": {
"__rl": true,
"mode": "id",
"value": "={{ $json.id }}"
}
},
"credentials": {
"googleDriveOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 3
},
{
"id": "57526f8a-9ee1-4d12-a9c4-a3b636f18e50",
"name": "Compose Notification",
"type": "n8n-nodes-base.code",
"position": [
1120,
660
],
"parameters": {
"jsCode": "// Get summary data\nconst summary = $('Assemble Backup Metadata').first().json;\nconst config = $('Backup Configurator').first().json;\n\n// Check if cleanup ran and if there were deletions\nlet cleanupInfo = '';\nif (config.enable_cleanup) {\n  try {\n    // Try to access Delete Old Backup node\n    const deletedFolders = $('Remove Old Backup').all();\n    \n    if (deletedFolders && deletedFolders.length > 0) {\n      // Check if it actually deleted folders (not just the false flag)\n      const actualDeletions = deletedFolders.filter(item => item.json.has_folders !== false);\n      if (actualDeletions.length > 0) {\n        cleanupInfo = `\\n\ud83d\uddd1\ufe0f *Cleanup:* ${actualDeletions.length} old backup(s) deleted (>${config.retention_days} days)`;\n      } else {\n        cleanupInfo = `\\n\u2705 *Cleanup:* No old backups to delete`;\n      }\n    } else {\n      cleanupInfo = `\\n\u2705 *Cleanup:* No old backups to delete`;\n    }\n  } catch (error) {\n    // Node wasn't executed (no old folders to delete)\n    cleanupInfo = `\\n\u2705 *Cleanup:* No old backups to delete`;\n  }\n} else {\n  cleanupInfo = '';\n}\n\n// Build status emoji\nconst statusEmoji = summary.has_failures ? '\u26a0\ufe0f' : '\u2705';\n\n// Build message\nlet message = `${statusEmoji} *Notion Backup Complete*\\n\\n`;\nmessage += `\ud83d\udcca *Summary:*\\n`;\nmessage += `\u2022 Total Databases: ${summary.total_databases}\\n`;\nmessage += `\u2022 Successful: ${summary.successful_backups} \u2705\\n`;\n\nif (summary.failed_backups > 0) {\n  message += `\u2022 Failed: ${summary.failed_backups} \u274c\\n`;\n}\n\nmessage += `\u2022 Total Pages: ${summary.total_pages_backed_up}\\n`;\nmessage += `\u2022 Total Size: ${summary.total_size}\\n`;\nmessage += cleanupInfo;\nmessage += `\\n\ud83d\udcc1 [Open Backup Folder](${summary.folder_url})`;\n\nif (summary.has_failures) {\n  message += `\\n\\n\u274c *Failed Databases:*\\n`;\n  summary.failed_databases.forEach(db => {\n    message += `\u2022 ${db}\\n`;\n  });\n}\n\nreturn {\n  message: message,\n  chat_id: config.telegram_chat_id,\n  parse_mode: 'Markdown'\n};"
},
"typeVersion": 2
},
{
"id": "78461e9b-f611-4aa2-ae2c-300055b28d6f",
"name": "Dispatch Telegram Alert",
"type": "n8n-nodes-base.telegram",
"position": [
1265,
710
],
"webhookId": "48cc16d9-d3a0-48e1-a3f3-530897e90c24",
"parameters": {
"text": "={{ $json.message }}",
"chatId": "={{ $json.chat_id }}",
"additionalFields": []
},
"credentials": {
"telegramApi": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 1.2
}
],
"active": false,
"pinData": [],
"settings": {
"executionOrder": "v1"
},
"versionId": "",
"connections": {
"Folder Deletion Check": {
"main": [
[
{
"node": "Remove Old Backup",
"type": "main",
"index": 0
}
],
[
{
"node": "Compose Notification",
"type": "main",
"index": 0
}
]
]
},
"Iterate Databases Batch": {
"main": [
[
{
"node": "Assemble Backup Metadata",
"type": "main",
"index": 0
}
],
[
{
"node": "Fetch Database Pages",
"type": "main",
"index": 0
}
]
]
},
"Manual Start Trigger": {
"main": [
[
{
"node": "Backup Configurator",
"type": "main",
"index": 0
}
]
]
},
"Cleanup Decision": {
"main": [
[
{
"node": "List Previous Backups",
"type": "main",
"index": 0
}
],
[
{
"node": "Compose Notification",
"type": "main",
"index": 0
}
]
]
},
"Send Metadata File": {
"main": [
[
{
"node": "Cleanup Decision",
"type": "main",
"index": 0
}
]
]
},
"List Previous Backups": {
"main": [
[
{
"node": "Filter Aged Backups",
"type": "main",
"index": 0
}
]
]
},
"Remove Old Backup": {
"main": [
[
{
"node": "Compose Notification",
"type": "main",
"index": 0
}
]
]
},
"Assemble Backup Metadata": {
"main": [
[
{
"node": "Send Metadata File",
"type": "main",
"index": 0
}
]
]
},
"Retrieve Notion Databases": {
"main": [
[
{
"node": "Initialize Backup Tracker",
"type": "main",
"index": 0
}
]
]
},
"Build Backup File": {
"main": [
[
{
"node": "Upload Backup Archive",
"type": "main",
"index": 0
}
]
]
},
"Filter Aged Backups": {
"main": [
[
{
"node": "Folder Deletion Check",
"type": "main",
"index": 0
}
]
]
},
"Fetch Database Pages": {
"main": [
[
{
"node": "Build Backup File",
"type": "main",
"index": 0
}
]
]
},
"Upload Backup Archive": {
"main": [
[
{
"node": "Iterate Databases Batch",
"type": "main",
"index": 0
}
]
]
},
"Compose Notification": {
"main": [
[
{
"node": "Dispatch Telegram Alert",
"type": "main",
"index": 0
}
]
]
},
"Initialize Backup Tracker": {
"main": [
[
{
"node": "Iterate Databases Batch",
"type": "main",
"index": 0
}
]
]
},
"Generate Drive Folder": {
"main": [
[
{
"node": "Retrieve Notion Databases",
"type": "main",
"index": 0
}
]
]
},
"Backup Configurator": {
"main": [
[
{
"node": "Generate Drive Folder",
"type": "main",
"index": 0
}
]
]
}
}
}