How to Automate Your Trading Journal Using Make.com in 2026

Manual trade journaling fails for one simple reason: the data entry happens after the session, when you're tired, when the emotional context of each trade has faded, and when it's easy to rationalize bad decisions rather than record them accurately. The solution isn't more discipline - it's removing the manual step entirely. If your journal updates itself, you'll actually use it.

Make.com (formerly Integromat) is a no-code automation platform that connects apps via a visual drag-and-drop scenario builder. It has native modules for Notion, OpenAI (ChatGPT), HTTP requests, JSON parsing, and data transformation. Combined with Interactive Brokers' Flex Query API or TradingView's webhook system, you can build a pipeline that captures every trade automatically, enriches it with metadata, and runs a weekly AI review without you touching anything. This guide shows exactly how to do that.

What You Need Before You Start

Before opening Make.com, you need three things in place. First, a data source - either an Interactive Brokers account with Flex Query enabled, or a TradingView account with a strategy that fires alerts. Second, a Notion workspace with a database set up to receive trades. Third, a Make.com account on at least the Core plan ($9/month) for enough operations to run daily automations.

Option A: Interactive Brokers Flex Query

Interactive Brokers Flex Query is a configurable report API built into your IBKR account. You define a report template that specifies which fields to export (symbol, trade date, open/close, quantity, fill price, commissions, realized P&L), then IBKR gives you a Query ID and a Token. Make.com's HTTP module can call the Flex Query endpoint with those credentials to pull the latest trades on any schedule. Go to IBKR > Reports > Flex Queries > Create New Activity Flex Query. Select Trades as the section, choose the fields: Symbol, TradeDate, OpenCloseIndicator, Buy/Sell, Quantity, TradePrice, Commission, RealizedPnL. Set the date range to 'Last 1 Calendar Day' and the output format to JSON. Save - you'll get a Query ID (a 10-digit number) and a Token (a 32-character string). Keep both handy.

Option B: TradingView Webhook

If you trade using TradingView alerts or Pine Script strategies, webhooks are a faster and simpler trigger. When an alert fires, TradingView sends a JSON payload to a URL you specify - in this case, a Make.com webhook URL. Your alert message in TradingView should be a JSON string like: {"symbol": "{{ticker}}", "action": "{{strategy.order.action}}", "price": {{close}}, "qty": {{strategy.order.contracts}}, "time": "{{timenow}}"}. Make.com's 'Webhooks > Custom webhook' module will receive this payload and parse it automatically. The TradingView webhook method logs trades in real time as they execute, whereas the IBKR Flex Query method is scheduled (daily or hourly).

Setting Up Your Notion Database

Create a new Notion database with these properties: Symbol (Title), Date (Date), Direction (Select: Long/Short), Quantity (Number), Entry Price (Number), Exit Price (Number), Commission (Number), Realized PnL (Number), R Multiple (Formula: empty for now), Setup Tag (Select), Notes (Text), Week Number (Formula). Also create a 'Trades' database and a separate 'Weekly Reviews' database - the second one will receive your ChatGPT weekly analysis. Share both databases with your Notion integration token (Settings > Connections > Develop your own integrations > New integration > copy the Internal Integration Token).

Building the Make.com Scenario: 8 Steps

Open Make.com, click 'Create a new scenario', and follow these steps in order. Each step corresponds to a module in the visual builder. The full scenario takes about 90 minutes to build if you're doing it for the first time.

The ChatGPT Prompt That Actually Works

The quality of your AI trade review depends almost entirely on the prompt you use. A generic prompt like 'analyze my trades' produces useless output. The prompt needs to constrain the output format, specify what to look for, and give ChatGPT a role with context. Here's the exact System prompt we use for the weekly review, which you can drop directly into Make.com's OpenAI module:

You are a trading performance coach reviewing a retail trader's weekly results.
The trader follows a momentum strategy on US equities and futures, targeting 2:1 R minimum.
For each week of trades provided, write a structured performance review in exactly this format:

WEEK SUMMARY
- Total trades: [n]
- Win rate: [x]%
- Average R: [x.x]
- Best trade: [symbol] [R]
- Worst trade: [symbol] [R]

PATTERN ANALYSIS
Identify 1-2 patterns in the losing trades. Be specific: mention symbol, time of day, and setup type if present in the data.

ACTIONABLE RULE FOR NEXT WEEK
Write one specific rule the trader should follow next week based on this data. Format: 'Do not [X] when [condition].'

Respond only with the structured review. Do not add commentary outside the format.

The 'Do not [X] when [condition]' format for the actionable rule is deliberately restrictive. Open-ended advice like 'be more patient' doesn't change behavior. A rule like 'Do not enter breakouts after 2:30 PM ET when the SPY is down more than 0.8% on the day' is specific enough to test and follow. After a few weeks you'll have a collection of rules you've actually derived from your own data, not borrowed from a trading book.

Handling Errors and Edge Cases

Automation breaks in predictable ways. The most common failure points in this scenario are: the IBKR Flex Query returning an error on days when IBKR's reporting servers are overloaded (usually monthly expiry Fridays), the Notion API rate limiting if you import more than 90 trades in a short window, and the OpenAI module failing if the response JSON doesn't parse cleanly.

For IBKR errors, add an 'Error handler' route from the HTTP module. Use 'Tools > Set Variable' to store the error message, then add a second HTTP module that retries the Flex Query request after a 10-minute delay using Make.com's 'Repeater' module (set max repetitions to 3). For Notion rate limiting, the Notion module in Make.com automatically handles 429 responses with exponential backoff - you don't need to do anything. For OpenAI parsing errors, add a 'Router' after the ChatGPT module: route 1 handles a clean JSON response and updates the Notion record; route 2 catches parse failures and sets a default setup_tag of 'Other' with a note of 'AI classification failed - review manually.'

Make.com's built-in execution history shows every scenario run with per-module inputs and outputs. Check it once a week for the first month. Common issues: the IBKR Flex Query returns zero trades on days you didn't trade (expected, not an error), TradingView webhooks occasionally fire duplicate alerts on unstable connections (add a 'Duplicate filter' using the trade timestamp as a deduplication key), and the Notion 'Search Objects' in the weekly review scenario sometimes returns more than 100 items if you trade frequently (add a 'Limit' of 200 records in the search module settings).

Make.com Operations Budget

Make.com charges per operation - each module execution in a scenario counts as one operation. Understanding your budget is important so you don't hit the monthly limit mid-month.

Most retail traders doing under 150 trades per month fit comfortably within Make.com Core at $9/month. If you scale beyond 300 trades/month or add more complex scenarios (like tagging every trade with a market regime label using a second OpenAI call), consider the Pro plan at $16/month for 10,000 operations with longer execution history retention.

What to Do Next

The fastest path to a working setup is to start with the TradingView webhook method, even if you also use IBKR for execution, because the webhook feedback loop is near-instant and easier to test. Create a TradingView strategy alert on a paper trading chart, point the webhook at your Make.com scenario, and trigger a test alert. Within 30 seconds you should see a new row appear in your Notion Trades database. That first successful test is the moment the whole system clicks.

Once the basic pipeline is working, go back and improve the ChatGPT trade tagging prompt. The default classification (Breakout, Pullback, Reversal, Trend-Follow, News-Fade, Other) is a starting point - replace 'Other' with setup names that match your actual playbook. If you trade gap-and-go stocks, add 'Gap-and-Go' as a tag option. If you trade VWAP reclaims, add that. After 4-6 weeks of tagged data in Notion, filter the database by setup_tag and sort by Realized PnL. You'll see immediately which setups are profitable and which aren't - and that data came from your own trades, processed automatically, without a single manual entry.

The weekly review automation is optional but compounds in value over time. After 12 weeks you have 12 written performance reviews, each with a specific rule derived from that week's data. Read through all of them together. The rules that keep repeating - 'Do not trade the first 15 minutes,' 'Avoid Fridays on small caps' - are your most important edge improvements. A purpose-built journal app can surface similar patterns, but none of them will generate rules in your specific voice based on your specific trade history the way a well-prompted ChatGPT does.