Syncing Raindrop.io Bookmarks to a Notion Database

Hey there, Darian here. Let’s talk about toolchains. One of the biggest productivity drains I see is context switching. For years, my Raindrop.io account was a black hole of good intentions—articles, tutorials, and resources I’d save but never look at again. My actual work happens in Notion. The manual process of copying links from one to the other was tedious, so I just didn’t do it. This little automation script changed that. It bridges the gap, turning my bookmarking habit into an organized, actionable knowledge base. It probably saves me a couple of hours a month, and more importantly, it ensures I actually use what I save.

Prerequisites

Before we dive in, make sure you have the following ready to go. This will make the process much smoother.

• A Raindrop.io account.
• A Notion account and a workspace where you have admin rights.
• Python 3 installed on your system.
• API credentials:
  • Raindrop.io Test App Token
  • Notion Integration Token
  • Notion Database ID

The Step-by-Step Guide

Step 1: Get Your API Credentials

First, we need to give our script permission to talk to both services.

1. Raindrop.io Token: Go to your Raindrop.io settings, click on the “Apps” tab, and create a new “Test App”. Give it a name like “Notion Sync” and it will generate an API token for you. Copy this token; we’ll need it soon.
2. Notion Integration Token: Go to Notion’s My Integrations page. Create a “New integration”, give it a name, and associate it with your workspace. On the next screen, copy the “Internal Integration Secret”. This is your Notion token.

Step 2: Prepare Your Notion Database

Our script needs a specific database structure to work correctly. Create a new, full-page database in Notion with the following properties. The names and types must match exactly.

• Name (Type: Title) – This is the default property.
• URL (Type: URL)
• Tags (Type: Multi-select)
• Raindrop ID (Type: Number) – This is crucial for preventing duplicates.
• Created At (Type: Date)

Once the database is created, you need to “share” it with the integration you made in Step 1. Click the three dots in the top-right corner of the Notion page, find “Connections”, and add your “Notion Sync” integration.

Pro Tip: To get the Database ID, look at your database’s URL. It will be in this format: notion.so/your-workspace/DATABASE_ID?v=.... The ID is that long string of characters between the slash and the question mark. Copy it.

Step 3: The Python Script

Now for the fun part. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Just make sure you’re in an isolated environment. You’ll need to install two libraries. In your terminal, you’d typically run commands to install `requests` for making API calls and `python-dotenv` for managing our secret keys.

Next, create a file named config.env in your project directory. This is where we’ll store our secrets so we don’t hardcode them in the script. It should look like this:

RAINDROP_TOKEN="your_raindrop_token_here"
NOTION_TOKEN="your_notion_integration_token_here"
NOTION_DATABASE_ID="your_notion_database_id_here"

Now, create your Python script file, let’s call it sync_script.py. Here is the full code. I’ve added comments to explain what each part does.

import os
import requests
from dotenv import load_dotenv
from datetime import datetime

# Load environment variables from config.env
load_dotenv('config.env')
RAINDROP_TOKEN = os.getenv('RAINDROP_TOKEN')
NOTION_TOKEN = os.getenv('NOTION_TOKEN')
NOTION_DATABASE_ID = os.getenv('NOTION_DATABASE_ID')

# API Endpoints and Headers
RAINDROP_API_URL = "https://api.raindrop.io/rest/v1/raindrops/0" # 0 for 'Unsorted' collection
NOTION_API_URL = "https://api.notion.com/v1/"

NOTION_HEADERS = {
    "Authorization": f"Bearer {NOTION_TOKEN}",
    "Content-Type": "application/json",
    "Notion-Version": "2022-06-28",
}

def get_existing_notion_ids():
    """Fetches all Raindrop IDs currently in the Notion database to prevent duplicates."""
    print("Fetching existing bookmark IDs from Notion...")
    existing_ids = set()
    query_url = f"{NOTION_API_URL}databases/{NOTION_DATABASE_ID}/query"
    
    has_more = True
    next_cursor = None
    
    while has_more:
        payload = {}
        if next_cursor:
            payload['start_cursor'] = next_cursor
            
        response = requests.post(query_url, headers=NOTION_HEADERS, json=payload)
        if response.status_code != 200:
            print(f"Error fetching from Notion: {response.text}")
            return existing_ids

        data = response.json()
        
        for item in data.get('results', []):
            raindrop_id_prop = item.get('properties', {}).get('Raindrop ID', {})
            if raindrop_id_prop and 'number' in raindrop_id_prop:
                existing_ids.add(raindrop_id_prop['number'])
        
        has_more = data.get('has_more', False)
        next_cursor = data.get('next_cursor')
        
    print(f"Found {len(existing_ids)} existing bookmarks in Notion.")
    return existing_ids

def fetch_raindrop_bookmarks():
    """Fetches the latest bookmarks from a specific Raindrop.io collection."""
    print("Fetching new bookmarks from Raindrop.io...")
    headers = {"Authorization": f"Bearer {RAINDROP_TOKEN}"}
    params = {"perpage": 50} # Adjust as needed, max is 50
    response = requests.get(RAINDROP_API_URL, headers=headers, params=params)

    if response.status_code == 200:
        return response.json().get('items', [])
    else:
        print(f"Error fetching from Raindrop.io: {response.text}")
        return []

def add_bookmark_to_notion(bookmark):
    """Adds a single bookmark to the Notion database."""
    page_create_url = f"{NOTION_API_URL}pages"
    
    # Format tags for Notion's multi-select property
    notion_tags = [{"name": tag} for tag in bookmark.get('tags', [])]

    # Format created date for Notion's date property
    created_date = datetime.fromisoformat(bookmark['created'].replace("Z", "+00:00")).isoformat()

    new_page_data = {
        "parent": {"database_id": NOTION_DATABASE_ID},
        "properties": {
            "Name": {
                "title": [{"text": {"content": bookmark.get('title', 'No Title')}}]
            },
            "URL": {
                "url": bookmark.get('link')
            },
            "Tags": {
                "multi_select": notion_tags
            },
            "Raindrop ID": {
                "number": bookmark.get('_id')
            },
            "Created At": {
                "date": {"start": created_date}
            }
        }
    }
    
    response = requests.post(page_create_url, headers=NOTION_HEADERS, json=new_page_data)
    
    if response.status_code == 200:
        print(f"Successfully added: {bookmark.get('title')}")
    else:
        print(f"Failed to add '{bookmark.get('title')}': {response.status_code} - {response.text}")

def main():
    """Main function to run the sync process."""
    existing_ids = get_existing_notion_ids()
    raindrop_bookmarks = fetch_raindrop_bookmarks()

    new_bookmarks_count = 0
    for bookmark in raindrop_bookmarks:
        if bookmark['_id'] not in existing_ids:
            add_bookmark_to_notion(bookmark)
            new_bookmarks_count += 1
    
    if new_bookmarks_count == 0:
        print("No new bookmarks to sync. Everything is up to date.")
    else:
        print(f"Sync complete. Added {new_bookmarks_count} new bookmarks.")

if __name__ == "__main__":
    main()

Pro Tip: In my production setups, I add more robust error handling and logging. For instance, if a Notion API call fails, I might implement a retry mechanism with exponential backoff. For this tutorial, I’ve kept it clean and simple to focus on the core logic.

Step 4: Automate the Sync

Running this script manually is fine, but the real power comes from automation. If you’re on a Linux-based system, a cron job is the classic way to do this.

You would typically edit your crontab to add a new line. This example runs the script every Monday at 2:00 AM.

0 2 * * 1 python3 /path/to/your/sync_script.py

Make sure to use the correct path to your Python interpreter and script. The schedule 0 2 * * 1 means at minute 0 of hour 2 on every Monday. Adjust this to a frequency that makes sense for you.

Common Pitfalls (Where I Usually Mess Up)

• Notion Permissions: The single most common error is forgetting to share the database with your integration. If you get a 401 or 404 error from Notion, this is the first thing to check.
• Property Name Mismatch: The script’s dictionary keys (e.g., “Raindrop ID”, “Created At”) must perfectly match the property names in your Notion database, case-sensitivity and all.
• API Rate Limits: If you’re syncing thousands of bookmarks for the first time, you might hit API rate limits. The Notion API allows an average of three requests per second. My script is fairly slow, so it’s unlikely to be an issue unless you modify it heavily. If it happens, add a small `time.sleep(0.5)` inside the loop.

Conclusion

And that’s it. You’ve now automated the pipeline from a quick-capture tool (Raindrop.io) to a long-term knowledge management system (Notion). This kind of small, targeted automation is what DevOps is all about—identifying friction in a workflow and building a bridge to make it seamless. It frees you up to focus on the high-value work: actually using the information you’ve curated. Happy syncing!

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions