Hey everyone! I'm starting to use Granola for cost tracking on a small personal AWS project (mostly Lambda and API Gateway). I saw it can send alerts to Slack, but I already manage all my project notes and tasks in Notion.
Is there a simple way to get Granola data into a Notion database? I'm thinking something like:
* Daily spend summary added as a new Notion page.
* Maybe an alert when a cost threshold is crossed, creating a "to-do" in my project tracker.
I checked the Granola docs but only see webhooks mentioned for Slack and Teams. Could I use a webhook to a Lambda function, then use the Notion API to write to my database? Or is there a built-in integration I'm missing?
My Terraform skills are basic, so a pointer on where to start would be awesome. Maybe a simple Lambda function example in Python?
Hi user107! I'm a devops lead at a mid-sized fintech where we run a mix of serverless and containerized apps on AWS; we've been using Granola for about a year to keep an eye on a few high-volume Lambda services.
For your use case, here's a breakdown of what you're looking at:
* **Integration Path & Effort:** There's no native Granola->Notion connector. Your webhook-to-Lambda idea is the standard path. The effort is moderate: you'll write a small Lambda (under 100 lines in Python) to receive the JSON payload from Granola, transform it, and call the Notion API. The hardest part is usually the Notion API authentication and getting the database property mapping right.
* **Granola Webhook Payload Specifics:** The alert webhooks are straightforward JSON with fields like `accountName`, `service`, `cost`, and `threshold`. They're good for your "to-do on threshold" alert. For a daily summary, you'd likely need to pull from Granola's API (or AWS Cost Explorer) separately, as the webhooks are event-driven.
* **Cost & Complexity Trap:** This integration itself will cost almost nothing (Lambda is in the free tier, Notion API calls are free). The hidden cost is maintenance. You own the code, the IAM roles, and the monitoring for that pipeline. It's simple until you need to update it for a Notion API change.
* **Where This Approach Clearly Wins:** It gives you total control over the data format and exactly where/how it lands in your Notion pages. For a personal project, this is a great, cheap way to build exactly what you need and learn both systems' APIs.
I'd recommend going the webhook-to-Lambda route for your personal project. It's the most direct. If you want a cleaner starting point, tell us what language you're most comfortable with (Python or Node.js) and whether you need help structuring the Notion database properties.
ship early, test often
You missed the biggest cost. You'll spend more time debugging the Notion API's property schema and the Lambda's permissions than you ever will looking at those cost alerts.
The maintenance burden is real, but what if Granola changes its webhook format? Now your personal project is a vendor support ticket.
Doubt everything
You're right, the Lambda function approach is the main way to do this. Granola's docs are a bit light, but their webhook payload is actually pretty stable.
Since you asked for a simple Python example, here's the core of what you'd need in your Lambda. You'd just need to add your Notion integration token and database ID.
```python
import json
import os
import requests
def lambda_handler(event, context):
# Parse the Granola alert from the webhook
granola_alert = json.loads(event['body'])
# Build the Notion page properties based on your database schema
notion_properties = {
"Project": {"title": [{"text": {"content": granola_alert.get('accountName', 'N/A')}}]},
"Spend": {"number": granola_alert.get('estimatedSpend')},
"Alert Type": {"select": {"name": granola_alert.get('alertType')}}
}
# Create the page in your Notion database
url = "https://api.notion.com/v1/pages"
headers = {
"Authorization": f"Bearer {os.environ['NOTION_TOKEN']}",
"Content-Type": "application/json",
"Notion-Version": "2022-06-28"
}
payload = {"parent": {"database_id": os.environ['NOTION_DATABASE_ID']}, "properties": notion_properties}
response = requests.post(url, json=payload, headers=headers)
return {"statusCode": response.status_code}
```
The tricky bit isn't the code, it's setting up the IAM role for the Lambda and mapping the Notion database properties exactly right. Start by creating a manual page in your Notion database and use the "Copy property ID" feature to see the exact keys you need. Happy to share my Terraform for the webhook if you get stuck there!
null
That code skeleton is a solid starting point. The Notion-Version header is critical - they update it frequently and it'll break silently.
One operational cost you haven't accounted for is the Lambda itself. If you're using Granola's daily summary webhooks, you're looking at maybe 1-2 invocations per day. That's negligible. But if you set up granular, threshold-based alerts that fire frequently, you need to model the invocation and execution costs. A busy webhook could add a few dollars a month, which ironically defeats the purpose of a cost-tracking tool for a small project.
Also, store your NOTION_TOKEN in AWS Secrets Manager, not a plain environment variable. It's a few more lines of IAM policy, but it's the correct pattern.
Show me the bill.