Complete Guide: Syncing Gmail Emails to Notion

Table of Content

Phase 1: Notion API Setup
1. Create a Notion Integration (API Key)
2. Create the Notion Database
3. Share the Database with the Integration
Phase 2: Google Apps Script Setup and Deployment
4. Create the Google Apps Script Project
5. Configure the Script Properties
6. Run and Authorize the Script
7. Set up the Time-Driven Trigger

This guide provides the complete, step-by-step process for connecting Gmail to Notion using Google Apps Script (GAS).

Phase 1: Notion API Setup

1. Create a Notion Integration (API Key)

Go to the Notion Integrations Page.
Click + New integration.
Give it a name (e.g., "Gmail Sync").
Associate it with the workspace you are using.
Under "Content Capabilities," make sure Read content and Insert content are checked.
Click Submit.
IMPORTANT: On the next screen, copy the Internal Integration Token and save it securely. This is your NOTION_API_KEY.

2. Create the Notion Database

In your Notion workspace, create a new page and turn it into a Database (Table View).
Name the database (e.g., "Email Inbox").

Property Name	Property Type	Notes
Subject	Title	This will hold the Email Subject. (Default column)
Date	Date	This will hold the received date.
Link to Email	URL	This will hold the direct Gmail URL to the message.
Sender	Text	The email address of the sender.
Snippet	Text	A short preview of the email content.
Status	Select	Ensure “Status” select option “📥 Inbox”

3. Share the Database with the Integration

Open the Notion Database page you just created.
Click the ... (three dots) menu in the top right corner.
Click Add connections at the bottom of the menu.
Search for and select the integration you created in Step 1 (e.g., "Gmail Sync").
IMPORTANT: Once the integration is connected, copy the Database ID from the URL. The URL format is https://www.notion.so/{workspace_name}/{**DATABASE_ID**}?v=.... Copy the 32-character string that appears immediately after the workspace name. This is your NOTION_DATABASE_ID.

Phase 2: Google Apps Script Setup and Deployment

4. Create the Google Apps Script Project

Go to script.google.com and click + New project.
Rename the project (e.g., "Gmail to Notion Sync").
Replace the default Code.gs content with the script provided in the next file block.

5. Configure the Script Properties

The script uses script properties to securely store your Notion keys and settings.

In the Apps Script editor, click the Settings icon (⚙) on the left sidebar.
Scroll down to Script properties.
Click + Add script property and enter the following three properties, using the values you copied from Notion:

Property Key	Property Value	Description
`NOTION_API_KEY`	`secret_...`	Your 32-character Integration Token.
`NOTION_DATABASE_ID`	`a9b2c...`	Your 32-character Database ID.
`GMAIL_SEARCH_QUERY`	`is:starred OR label:"Send to Notion"`	The Gmail query to find emails.
`SYNC_LABEL_NAME`	`Notion Synced`	The label the script will apply after syncing.

Click Save script properties.

6. Run and Authorize the Script

Go back to the Editor icon (<>) on the left sidebar.

‣

Code.gs

/**
 * Converts plain text content (like an email body) into an array of
 * Notion paragraph blocks, respecting double line breaks as paragraph separators.
 * This ensures the content inside the Notion page is formatted cleanly,
 * and it now converts recognized URLs into clickable Notion link objects.
 *
 * @param {string} text The plain text content from the email body.
 * @returns {Array<Object>} An array of Notion block objects.
 */
function plainTextToNotionBlocks(text) {
  if (!text) return [];
  
  // Regex to reliably capture URLs starting with http:// or https://.
  // The capturing parentheses around the regex are CRITICAL for the split method.
  const URL_REGEX = /(https?:\/\/[^\s]+)/g;

  // 1. Clean up excessive whitespace at the start/end and split into paragraphs by double line break.
  const paragraphs = text.trim().split(/\n\s*\n/);
  
  // 2. Filter out empty paragraphs and map to Notion block structure.
  return paragraphs
    .filter(p => p.trim().length > 0)
    .map(p => {
      // Clean up remaining single line breaks within a paragraph (replaces them with spaces)
      const cleanText = p.replace(/(\r\n|\n|\r)/gm, ' ').trim();
      
      // Split the paragraph text by the URL regex. The URLs themselves will be kept in the array.
      const parts = cleanText.split(URL_REGEX); 
      
      // Process each part to determine if it's text or a link
      const richTextArray = parts.map(part => {
        if (!part) return null; // Ignore empty strings from the split

        // Check if the part matches the URL regex (means it was a captured group)
        if (part.match(URL_REGEX)) {
          // Found a URL, create a rich text object with the 'link' property
          return {
            "type": "text",
            "text": {
              "content": part,
              "link": {
                "url": part
              }
            }
          };
        } else {
          // Regular text
          return {
            "type": "text",
            "text": {
              "content": part
            }
          };
        }
      }).filter(Boolean); // Remove any null values from filtering

      // Return the Notion paragraph block with the resulting richTextArray
      return {
        "object": "block",
        "type": "paragraph",
        "paragraph": {
          "rich_text": richTextArray
        }
      };
    });
}


/**
 * Main function to sync emails from Gmail to Notion.
 *
 * This function performs the following steps:
 * 1. Retrieves configuration (API Key, DB ID, Search Query) from Script Properties.
 * 2. Defines the label name used for tracking synced emails ("Notion Synced").
 * 3. Searches Gmail for threads matching the query AND which have NOT been synced yet.
 * 4. Iterates over new threads, extracts email data, and creates a page in Notion.
 * 5. Adds the "Notion Synced" label to the thread to prevent future duplicates.
 */
function syncEmailsToNotion() {
  const props = PropertiesService.getScriptProperties();
  const NOTION_API_KEY = props.getProperty('NOTION_API_KEY');
  const NOTION_DATABASE_ID = props.getProperty('NOTION_DATABASE_ID');
  
  // The query should look for emails that meet the criteria (e.g., Starred or labeled) 
  // AND which have NOT been marked with the SYNC_LABEL_NAME yet.
  const GMAIL_SEARCH_QUERY = props.getProperty('GMAIL_SEARCH_QUERY');
  
  // The label applied after successful syncing to prevent duplication
  const SYNC_LABEL_NAME = props.getProperty('SYNC_LABEL_NAME'); 
  
  // Final combined search query
  const finalQuery = `${GMAIL_SEARCH_QUERY} -label:"${SYNC_LABEL_NAME}"`;

  if (!NOTION_API_KEY || !NOTION_DATABASE_ID) {
    Logger.log("ERROR: Notion API Key or Database ID is missing. Check Script Properties.");
    return;
  }
  
  Logger.log(`Searching Gmail with query: ${finalQuery}`);

  // 1. Fetch Gmail Threads
  const threads = GmailApp.search(finalQuery, 0, 50); // Fetch up to 50 threads per run

  // Get or create the label used for tracking synced emails
  const syncLabel = GmailApp.getUserLabelByName(SYNC_LABEL_NAME) || GmailApp.createLabel(SYNC_LABEL_NAME);

  if (threads.length === 0) {
    Logger.log("No new emails found matching the criteria.");
    return;
  }

  Logger.log(`Found ${threads.length} new threads to sync.`);
  
  threads.forEach(thread => {
    // Get the first message in the thread for subject, date, and sender info
    const message = thread.getMessages()[0];
    
    // Extract data
    const subject = message.getSubject();
    const date = message.getDate().toISOString();
    const sender = message.getFrom();
    
    // Get the full plain body for generating page content
    const fullBody = message.getPlainBody();
    
    // Truncate to 2000 characters, remove line breaks, and add ellipsis if needed for the 
    // database's single-line 'Snippet' property.
    const snippet = fullBody.substring(0, 2000).replace(/(\r\n|\n|\r)/gm, " ") + (fullBody.length > 2000 ? '...' : '');
    
    // NEW: Convert the full body (with line breaks) into an array of Notion paragraph blocks, now with clickable links.
    const pageContentBlocks = plainTextToNotionBlocks(fullBody);
    
    // Construct the direct link to the message
    const gmailUrl = `https://mail.google.com/mail/u/0/#all/${thread.getId()}`;

    const emailData = {
      subject: subject,
      date: date,
      sender: sender,
      snippet: snippet,
      url: gmailUrl,
      pageContentBlocks: pageContentBlocks // Pass the formatted blocks
    };

    // 2. Create Notion Page
    try {
      createNotionPage(emailData, NOTION_API_KEY, NOTION_DATABASE_ID);
      Logger.log(`Successfully synced: ${subject}`);
      
      // 3. Mark Thread as Synced
      thread.addLabel(syncLabel);
      Logger.log(`Applied label "${SYNC_LABEL_NAME}" to thread.`);

    } catch (e) {
      Logger.log(`Error processing ${subject}: ${e.message}`);
    }
  });

  Logger.log("Sync process finished.");
}


/**
 * Sends a request to the Notion API to create a new page in the database.
 * @param {Object} emailData - Object containing email details (subject, date, sender, snippet, url, pageContentBlocks).
 * @param {string} apiKey - The Notion API Integration Token.
 * @param {string} databaseId - The ID of the Notion Database.
 */
function createNotionPage(emailData, apiKey, databaseId) {
  const url = 'https://api.notion.com/v1/pages';

  // Construct the JSON payload for the Notion API
const payload = {
    "parent": {
      "database_id": databaseId
    },
    "properties": {
      // 1. "Name" (Title property)
      "Subject": {
        "title": [
          {
            "text": {
              "content": emailData.subject
            }
          }
        ]
      },
      // 2. "Date" (Date property)
      "Date": {
        "date": {
          "start": emailData.date // ISO 8601 format
        }
      },
      // 3. "Link" (URL property)
      "Link to Email": {
        "url": emailData.url
      },
      // 4. "Sender" (Text property)
      "Sender": {
        "rich_text": [
          {
            "text": {
              "content": emailData.sender
            }
          }
        ]
      },
      // 5. "Snippet" (Text property - still a single, clean line for the database column)
      "Snippet": {
        "rich_text": [
          {
            "text": {
              "content": emailData.snippet
            }
          }
        ]
      },
      // 6. NEW: "Direction" (Select property with default value "📥 Received")
      "Status": {
        "select": {
          "name": "📥 Inbox"
        }
      }
    },
    // The "children" array now uses the properly formatted pageContentBlocks.
    "children": emailData.pageContentBlocks.length > 0 
                ? emailData.pageContentBlocks 
                : [{ "object": "block", "type": "paragraph", "paragraph": { "rich_text": [{ "type": "text", "text": { "content": "No text content found in email." } }] } }]
  };

  const options = {
    method: 'post',
    contentType: 'application/json',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Notion-Version': '2022-06-28' // Use a stable Notion API version
    },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true // Allows inspection of error responses
  };

  const response = UrlFetchApp.fetch(url, options);
  const responseCode = response.getResponseCode();

  if (responseCode !== 200) {
    const errorBody = response.getContentText();
    Logger.log(`Notion API Error (${responseCode}): ${errorBody}`);
    throw new Error(`Notion API failed to create page. Status: ${responseCode}`);
  }
}

Select the syncEmailsToNotion function from the dropdown menu (it should be selected by default).
Click the Run button.
The first time you run it, you must grant permissions:

Click Review permissions.
Select your Google Account.
You will see a warning screen; click Advanced and then Go to “Project Name”

(unsafe).

Click Allow to grant access to Gmail, external connection services (UrlFetchApp), and configuration (PropertiesService).

7. Set up the Time-Driven Trigger

This step ensures the script runs automatically (e.g., every 15 minutes).

In the Apps Script editor, click the Triggers icon (⏰) on the left sidebar.
Click + Add Trigger in the bottom right.
Set the following options:

Choose which function to run: syncEmailsToNotion
Choose deployment to run: Head
Select event source: Time-driven
Select type of time-based trigger: Hour timer (or Minutes timer)
Select hour of day/interval: Every 15 minutes (Recommended)

Click Save.

The setup is complete! The script will now run on the schedule you set.

🎁 Are you founder or startup? Get 30 Notion Plus & AI for FREE with Partner link: https://affiliate.notion.so/experience

Support My Work