Automate Your Morning Market Note with Claude Code

This post contains affiliate links. If you sign up through one, we may earn a commission at no extra cost to you. How we handle this.

The morning note has two halves. The first is mechanical: what happened overnight to the names you cover, what's on today's calendar, and what the latest numbers say. The second is the judgment call: what it means and what you'd do about it. Most of the 6am scramble goes to the first half, and it's the half that doesn't need you.

This walkthrough automates the mechanical half. A scheduled Claude Code run reads overnight news for your watchlist, pulls company data over MCP for the names that moved, checks it against a calendar that a weekly run maintains, and leaves a draft note in a folder before you sit down. You read it, fix it, add the call, and send it. The result is a daily habit that takes ten minutes instead of sixty.

One honest caveat up front: a draft built from web search is only as good as its sources. The design below is built around that. Every figure carries a source and a time, and anything the run couldn't verify says so. You are still the author of whatever you send out.

What Goes in the Note

The Equity Research Morning Note playbook defines the format sell-side desks use: a one-page note with a top-call headline, overnight earnings reactions, key events today, and a trade idea with risk parameters. It's the right skeleton, because it forces an opinion instead of a news summary.

We split that skeleton by who does what:

The Data Steps, and What Each Tool Is For

A morning note touches three kinds of data, and no single tool covers all of them. Be clear about which job each one does.

Overnight news and market moves: web search

Claude Code can search the web and read pages. That covers headlines, press releases, filings and the macro prints. It isn't a market-data terminal. Search results can lag, and a pre-market price from a web page may be minutes or hours old. So the run is told to label every price with its source and time, and you confirm live levels on your own screen.

Company fundamentals: Fiscal.ai over MCP

When a name has an overnight event, say an earnings release, a guidance change or an M&A headline, the useful context is the numbers behind it: the latest reported financials and what management said last time. Fiscal.ai exposes a hosted MCP server, so Claude can query that directly instead of scraping it. It has a free tier covering 100 large-cap companies with 250 calls a day, which applies through MCP as well, and wider coverage on paid plans. The setup is covered in our Fiscal.ai MCP walkthrough. Pulling data only for names that moved keeps you well inside the daily call cap.

Your screen: Koyfin as the thing you look at

Koyfin is the dashboard you open at 7am, not an input to the run. It's excellent for watching a watchlist, charts and macro, but its financials and estimates can't be exported, so there's nothing for Claude to read. The note's job is to tell you which charts to open. We cover the split in Koyfin vs Fiscal.ai.

Set Up the Project

morning-note/
├── CLAUDE.md          ← note format, rules, your coverage
├── watchlist.csv      ← ticker, name, one line on why you watch it
├── catalysts.md       ← maintained weekly by Claude
├── .mcp.json          ← Fiscal.ai connection
├── run.sh             ← what the scheduler calls
└── notes/             ← one file per day

Connect Fiscal.ai for an unattended run

The interactive setup uses an OAuth sign-in in your browser, which a scheduled job can't complete. Use the API-key method instead. Put the key in an environment variable with a name of your own and reference it from .mcp.json:

{
  "mcpServers": {
    "fiscal": {
      "type": "http",
      "url": "https://api.fiscal.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${FISCAL_API_KEY}"
      }
    }
  }
}

Claude Code expands ${VAR} in the url and headers of HTTP servers. Don't reuse a name that Claude Code treats as a credential, such as ANTHROPIC_API_KEY, because those read as empty inside a remote server's headers. Keep the key out of the file and out of version control, and add .mcp.json to .gitignore if it ever contains a literal token.

Write the rules into CLAUDE.md

Start from the playbook template, then add the rules that stop a draft from misleading you:

## Morning note rules
- Format: top call (one line), overnight table, today's events, numbers
  for names with an event, one trade idea with risk, open questions.
- Every price, percentage or figure needs a source and a timestamp from
  THIS run. If a source did not give it, write "not verified". Never
  estimate a number.
- Separate fact from rumor. Mark unconfirmed reports "unconfirmed".
- Pull Fiscal.ai data only for names with a material overnight event.
- Never write buy/sell language as fact. The trade idea is a draft for
  my review and must state what would prove it wrong.
- If US markets are closed today, say so in one line and stop.

The Two Prompts

Weekly: build the catalyst calendar

Run this on Sunday. The Catalyst Calendar playbook builds the structure: earnings dates, conferences, product launches and macro events, tagged by impact. The daily run then reads the file instead of rediscovering the week every morning.

Daily: write the note

That last sentence matters. A draft that tells you what it didn't check is more useful than one that sounds complete.

Schedule It

Claude Code has three scheduling options, and they behave differently in ways that matter for a 7am deliverable:

For this workflow, a Desktop scheduled task or a plain cron job is the fit, because the run needs your local watchlist and notes folder. Two behaviors to plan around:

• A sleeping computer skips the run. Desktop tasks only fire while the app is running and your computer is awake. When it wakes it makes one catch-up run, so a 6:30 task can land at 9am. Each task also starts a few minutes after its scheduled time. Turn on Keep computer awake, or put a guard in the prompt, as the rule above does for closed markets.
• Don't use /loop for this. It's session-scoped, recurring tasks expire after seven days, and runs are deliberately jittered by up to half the interval. A daily task can start up to 30 minutes late. That's fine for polling a deploy and wrong for a note that needs to be ready at 7.

If you'd rather have exact timing under your own control, call Claude Code non-interactively from cron (or Task Scheduler on Windows). The -p flag runs a prompt and exits, and --allowedTools pre-approves what the run may use:

#!/usr/bin/env bash
# run.sh — called by cron at 06:30 on weekdays
set -euo pipefail
cd "$(dirname "$0")"

claude -p "Write the morning note for $(date +%F) per CLAUDE.md. Save it as notes/$(date +%F).md." \
  --allowedTools "Read,Write,WebSearch,WebFetch,mcp__fiscal" \
  --permission-prompts none \
  --max-budget-usd 1.00 \
  --output-format json > "notes/run-$(date +%F).json"

# crontab:  30 6 * * 1-5  /path/to/morning-note/run.sh

A few notes on that command. Without --bare, claude -p reads CLAUDE.md and connects the servers in .mcp.json from the project folder, which is what we want here. (Bare mode skips both, and you'd have to pass them in explicitly.) mcp__fiscal allows every tool on the server named fiscal. --permission-prompts none denies anything not pre-approved instead of hanging with no one to answer, and it needs a recent Claude Code version. --max-budget-usd caps spend per run, so a loop gone wrong costs a dollar, not a surprise.

Whichever scheduler you use, run it by hand once first and watch for permission prompts. Desktop tasks have a Run now button for exactly this, and any tool the run is stopped on has to be allowed before the first unattended morning.

What Can Go Wrong

• Stale or wrong prices. This is the most important one. Use the note to decide where to look, not as the price source. The sourcing rule makes the gaps visible.
• Rumors reported as facts. Overnight news is full of unconfirmed reports. The "unconfirmed" rule helps, but you should read the source on anything you'd act on.
• Holidays and half-days. A weekday cron fires on market holidays. The closed-markets rule handles it, but it relies on a source confirming it.
• Coverage gaps. The free Fiscal.ai tier covers large caps. For small caps or non-US names, the note will say the data wasn't available. Believe it, and don't let Claude fill in from memory.
• Silent failure. A job that doesn't run produces no note and no error. Check that today's file exists before you rely on it, or have the script write a one-line failure file when the exit code is non-zero.
• Compliance. If the note goes outside your head or your team, your firm's research and communications rules apply to it exactly as they would to one you wrote by hand. Check what they require before it goes to clients.

Make the Habit Stick

The setup takes an afternoon. What makes it worth having is the five minutes after each note. When the draft gets something wrong, such as a stale number, a missed name or a rumor stated as fact, add one line to CLAUDE.md so it can't happen the same way twice. After a month the rules file is a record of exactly how your desk wants the note written, which is more valuable than any one draft.

If you want it delivered alongside your day, the Daily Morning Briefing playbook folds calendar, inbox and tasks into the same kind of run. And if you want to go from the note to a full model on a name that moved, the DCF walkthrough picks up where this one stops.

This article is for education, not investment advice. Scheduling behavior and plan limits come from Anthropic's and the vendors' documentation as of October 2026. Confirm them on the current docs before you rely on them.