Your first stock quotes

Step 1 Open a terminal

A terminal is a window where you type commands and the computer answers in text. On Windows, open PowerShell from the Start menu. On macOS, open Terminal from Applications, then Utilities. On Linux, open your terminal app.

Each command in this course comes after a prompt: $ on macOS and Linux, PS> on Windows. Type the command without the prompt, then press Enter.

Step 2 Install uv

uv is a tool that installs Python, gives each project its own copy of the packages it uses, and runs your code. Install it with the command for your computer:

PS> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

$ curl -LsSf https://astral.sh/uv/install.sh | sh

On Linux it printed this; macOS and Windows print much the same:

$ curl -LsSf https://astral.sh/uv/install.sh | shdownloading uv 0.12.23 x86_64-unknown-linux-gnuinstalling to /home/you/.local/bin  uv  uvxeverything's installed!

Close the terminal and open a new one, so it can find uv.

Step 3 Install Git and VS Code

Git saves versions of your work; you start using it in Session 3. On Windows, download it from git-scm.com and keep the installer’s choices as they are. On macOS, typing git --version offers to install it. On Linux, install the git package with your system’s package manager.

VS Code is the editor you write code in. Download it from code.visualstudio.com, open it, and install the Python extension: open Extensions in the bar on the left, search for Python, and install the one by Microsoft.

Open a new terminal and check both tools. Your version numbers may be newer:

$ uv --versionuv 0.12.23 (x86_64-unknown-linux-gnu)$ git --versiongit version 2.47.3

Step 4 Tell Git who you are

Git writes a name and an email into every version you save. Set yours once, with your own name and email, and name the first line of work main, as GitHub does. Each command prints nothing when it works:

$ git config --global user.name "Your Name"$ git config --global user.email "[email protected]"$ git config --global init.defaultBranch main

Step 5 Make the project

Go to the folder where you keep your work, such as your home folder, and make a project. --no-package makes a project of plain scripts, the simplest kind; on Day 3 you turn it into a package. --python 3.14 sets the Python version the project uses, and uv downloads that version if your computer doesn’t have it. --description is the line pyproject.toml gives as what the project is.

$ uv init --no-package --python 3.14 --description "US equity market data in Python" market-dataInitialized project `market-data` at `/home/you/market-data`$ cd market-data$ ls -a....git.gitignore.python-versionREADME.mdmain.pypyproject.toml

uv made a folder, market-data, holding these files:

Open the folder in VS Code with File, Open Folder, and delete main.py: right-click it and choose Delete. You won’t need it. Here is what the project’s settings say so far:

$ cat .python-version3.14$ cat pyproject.toml[project]name = "market-data"version = "0.1.0"description = "US equity market data in Python"readme = "README.md"requires-python = ">=3.14"dependencies = []$ cat .gitignore# Python-generated files__pycache__/*.py[oc]build/dist/wheels/*.egg-info # Virtual environments.venv

Step 6 Add httpx2

A package is code someone else wrote that your project can use. httpx2 downloads data from the web. Add it:

$ uv add httpx2Using CPython 3.14.8 interpreter at: /usr/local/bin/python3.14Creating virtual environment at: .venvResolved 9 packages in 197msPrepared 7 packages in 61msInstalled 7 packages in 64ms + anyio==4.15.1 + h11==0.16.0 + httpcore2==2.13.1 + httpx2==2.13.1 + idna==3.20 + truststore==0.10.4 + typing-extensions==4.16.0$ cat pyproject.toml[project]name = "market-data"version = "0.1.0"description = "US equity market data in Python"readme = "README.md"requires-python = ">=3.14"dependencies = [    "httpx2>=2.13.1",]

• uv made .venv, the project’s own Python and packages, kept apart from every other project on your computer.
• It downloaded httpx2 and the packages httpx2 needs, and wrote httpx2 into pyproject.toml under dependencies.
• It wrote the exact version of every package to uv.lock. Saving that file with your code lets anyone install exactly the same versions.

Step 7 Get your Alpaca keys

Alpaca’s market data is free with an account, and the account needs no money. Every account comes with a paper trading account, which trades pretend money; this course uses its keys for market data.

• Sign up at alpaca.markets with your email, and confirm it from the email Alpaca sends.
• Log in to your dashboard at app.alpaca.markets, and check that Paper Trading is selected at the top left.
• On the Home page, find API Keys and choose Generate New Keys.
• Copy the key ID and the secret key for the next step. Alpaca shows the secret key only once; if you lose it, generate new keys.

Never paste the secret key into code, a chat or an email.

Step 8 Keep your keys out of Git

In VS Code, make a file called .env in the market-data folder, and put your two keys in it in place of the stand-ins, with no spaces or quotes:

APCA_API_KEY_ID=your-key-idAPCA_API_SECRET_KEY=your-secret-key

Make .env.example beside it, with the names and stand-in values. It is safe to commit:

# Copy to .env and set your own values. .env is in .gitignore; this file is not.APCA_API_KEY_ID=your-key-idAPCA_API_SECRET_KEY=your-secret-key

Then add these two lines to the end of .gitignore, so Git never saves .env:

# Your API keys and other settings for this computer only.env

Print the file to check it. A line starting with # is a comment, a note for people that Git skips:

$ cat .gitignore# Python-generated files__pycache__/*.py[oc]build/dist/wheels/*.egg-info # Virtual environments.venv # Your API keys and other settings for this computer only.env

Step 9 Download a quote

Make a new file in VS Code, quote.py, and type this in:

import os import httpx2 url = "https://data.alpaca.markets/v2/stocks/snapshots"keys = {    "APCA-API-KEY-ID": os.environ["APCA_API_KEY_ID"],    "APCA-API-SECRET-KEY": os.environ["APCA_API_SECRET_KEY"],}query = {"symbols": "AAPL", "feed": "delayed_sip"}response = httpx2.get(url, params=query, headers=keys, timeout=10)print(response.status_code)snapshot = response.json()["AAPL"]print(snapshot["latestTrade"])print(snapshot["latestQuote"])

Line 1

os is part of Python. os.environ holds the program’s environment variables, so your keys can be read from it.

Line 3

Load the httpx2 package.

Line 5

The address of Alpaca’s snapshots. A snapshot is a share’s latest trade, its latest quote and its bars for the day.

Lines 6 to 9

A dictionary of the two headers Alpaca reads your keys from, each filled from an environment variable. If a variable isn’t set, os.environ stops the program with a KeyError naming it.

Line 10

The query: the symbols to ask for, and the feed. delayed_sip is the free plan’s feed, every US exchange, 15 minutes behind.

Line 11

httpx2.get sends the request, with the query added to the address and the keys as headers, and waits for the answer. timeout=10 gives up after 10 seconds instead of waiting forever.

Line 12

Print the answer’s status code: 200 means it worked.

Line 13

.json() turns the answer’s JSON text into a Python dictionary of snapshots by ticker, and ["AAPL"] picks out Apple’s.

Lines 14 to 15

Print the latest trade, then the latest quote.

Run it. uv run runs a file with the project’s own Python and packages, and --env-file .env gives it your keys:

$ uv run --env-file .env quote.py200{'c': [' ', 'M'], 'i': 52983525029461, 'p': 330.27, 's': 343753, 't': '2026-10-06T20:00:00.000271834Z', 'x': 'Q', 'z': 'C'}{'ap': 330.3, 'as': 200, 'ax': 'Q', 'bp': 330.25, 'bs': 300, 'bx': 'Q', 'c': ['R'], 't': '2026-10-06T20:00:00.001044518Z', 'z': 'C'}

Alpaca keeps its names short, a letter or two each:

On the sample’s day New York was on daylight saving time, 4 hours behind UTC, so 20:00 in UTC was 16:00 there: the closing trade, as the market shut. Shares also trade before 9:30 and after 16:00, in smaller amounts, so run it in the evening and the latest trade is a later one. x, bx and ax name the exchange each price came from by a letter (Q is Nasdaq), and c and z are codes that describe the trade and the group of exchanges that reported it.

Python writes 330.30 as 330.3; it is the same number. Alpaca’s data is for your own use, so keep the prices to yourself: don’t publish them on a website.

Step 10 Pick out what matters

Replace quote.py with this. The new and changed lines are marked:

import os import httpx2 SNAPSHOTS_URL = "https://data.alpaca.markets/v2/stocks/snapshots"  def get_snapshots(symbols):    """Download each symbol's latest trade, quote and daily bars, 15 minutes behind."""    keys = {        "APCA-API-KEY-ID": os.environ["APCA_API_KEY_ID"],        "APCA-API-SECRET-KEY": os.environ["APCA_API_SECRET_KEY"],    }    query = {"symbols": ",".join(symbols), "feed": "delayed_sip"}    response = httpx2.get(SNAPSHOTS_URL, params=query, headers=keys, timeout=10)    response.raise_for_status()    return response.json()  def describe(symbol, snapshot):    """One line about a symbol: its last price, bid, ask and spread."""    last = snapshot["latestTrade"]["p"]    bid = snapshot["latestQuote"]["bp"]    ask = snapshot["latestQuote"]["ap"]    return (        f"{symbol}  last {last:.2f}  bid {bid:.2f}  ask {ask:.2f}  "        f"spread {ask - bid:.2f}"    )  snapshots = get_snapshots(["AAPL"])print(describe("AAPL", snapshots["AAPL"]))

Line 5

The address, in a name in capitals: a setting that never changes while the program runs.

Lines 8 to 17

A function: a named piece of code you can call. It takes a list of tickers, joins them with commas (",".join) so one request asks for all of them, stops with an error if the server answered with a problem (raise_for_status), and returns the snapshots by ticker.

Lines 20 to 28

A second function turns a snapshot into one line: the last price from the latest trade, the bid and ask from the latest quote, and the spread, ask − bid. :.2f inside an f-string, a string starting with f whose {…} parts are filled in, writes each with two decimal places.

Lines 31 to 32

Ask for Apple’s snapshot, with a list of one ticker in square brackets, and print its line.

$ uv run --env-file .env quote.pyAAPL  last 330.27  bid 330.25  ask 330.30  spread 0.05

Computers store numbers in binary, so 330.30 − 330.25 comes out as 0.05000000000001137, a hair over 0.05. :.2f prints it as 0.05. Code that moves real money uses exact decimal arithmetic for this reason; for reading quotes, two places are enough.

Step 11 Any ticker

Change the end of quote.py so it takes the ticker from the command line, and add a docstring at the top that says what the file does:

"""Print a stock's latest quote from Alpaca, 15 minutes behind the market. Run it with a ticker, such as:     uv run --env-file .env quote.py AAPL""" import osimport sys import httpx2 SNAPSHOTS_URL = "https://data.alpaca.markets/v2/stocks/snapshots"  def get_snapshots(symbols):    """Download each symbol's latest trade, quote and daily bars, 15 minutes behind."""    keys = {        "APCA-API-KEY-ID": os.environ["APCA_API_KEY_ID"],        "APCA-API-SECRET-KEY": os.environ["APCA_API_SECRET_KEY"],    }    query = {"symbols": ",".join(symbols), "feed": "delayed_sip"}    response = httpx2.get(SNAPSHOTS_URL, params=query, headers=keys, timeout=10)    response.raise_for_status()    return response.json()  def describe(symbol, snapshot):    """One line about a symbol: its last price, bid, ask and spread."""    last = snapshot["latestTrade"]["p"]    bid = snapshot["latestQuote"]["bp"]    ask = snapshot["latestQuote"]["ap"]    return (        f"{symbol}  last {last:.2f}  bid {bid:.2f}  ask {ask:.2f}  "        f"spread {ask - bid:.2f}"    )  if __name__ == "__main__":    symbol = sys.argv[1] if len(sys.argv) > 1 else "AAPL"    snapshots = get_snapshots([symbol])    if symbol not in snapshots:        sys.exit(f"No quote for {symbol}: check the ticker.")    print(describe(symbol, snapshots[symbol]))

Lines 1 to 6

A docstring: what the file does and how to run it, in triple quotes at the top.

Line 9

sys holds sys.argv, the list of words on the command line: the file’s name first, then anything typed after it.

Lines 39 to 41

This block runs only when you run quote.py itself, not when another file imports it, as the watchlist does in Session 2. It takes the ticker typed after the file’s name, or AAPL if there is none.

Lines 42 to 43

Alpaca leaves a ticker it doesn’t know out of its answer, so check before using it. not in is True when the dictionary has no such key. sys.exit with a message prints the message and ends the program with exit code 1, a program’s way of saying it failed.

$ uv run --env-file .env quote.py MSFTMSFT  last 522.48  bid 522.40  ask 522.52  spread 0.12

And a ticker that doesn’t exist:

$ uv run --env-file .env quote.py ZZZZNo quote for ZZZZ: check the ticker.

Step 1 Loop over a list

Make watchlist.py beside quote.py:

from quote import get_snapshots SYMBOLS = ["AAPL", "MSFT", "NVDA", "SPY", "QQQ"] snapshots = get_snapshots(SYMBOLS)for symbol in SYMBOLS:    snapshot = snapshots[symbol]    print(symbol, snapshot["latestTrade"]["p"], snapshot["prevDailyBar"]["c"])

Line 1

Use get_snapshots from quote.py. The if __name__ == "__main__": block you wrote keeps quote.py from printing Apple’s line when it is imported.

Line 3

A list: values in square brackets, in order. Three companies’ shares and two ETFs.

Line 5

One request for all five snapshots.

Lines 6 to 8

A for loop runs its indented lines once for each item in the list, with symbol holding the item. Each line prints the symbol, the last price, and the previous close: the close (c) of the previous day’s bar (prevDailyBar).

$ uv run --env-file .env watchlist.pyAAPL 330.27 326.8MSFT 522.48 525.1NVDA 185.12 182.95SPY 771.53 767.2QQQ 752.11 748.9

The next step works out each change and lines everything up.

Step 2 Line up the columns

from datetime import datetime from quote import get_snapshots SYMBOLS = ["AAPL", "MSFT", "NVDA", "SPY", "QQQ"]  def row(symbol, snapshot):    """One table row: symbol, last price, and change since the previous close."""    last = snapshot["latestTrade"]["p"]    previous = snapshot["prevDailyBar"]["c"]    change = last - previous    return f"{symbol:<6} {last:>10.2f} {change:>+8.2f} {change / previous:>+8.2%}"  def show(symbols):    """Print the time, a header, then one row per symbol, from one request."""    snapshots = get_snapshots(symbols)    print(f"\nQuotes at {datetime.now():%H:%M:%S}")    print(f"{'symbol':<6} {'last':>10} {'change':>8} {'%':>8}")    for symbol in symbols:        print(row(symbol, snapshots[symbol]))  show(SYMBOLS)

Lines 8 to 13

Work out the change, then lay out the row. Each {…} has a format after its colon: <6 puts the symbol on the left of 6 characters; >10.2f puts a number on the right of 10 characters, with 2 decimal places; a + shows its sign, plus or minus; and % writes a fraction as a percent, so 0.0106 becomes 1.06%.

Lines 16 to 22

Fetch every snapshot in one request, then print the time, a header whose widths match the rows, and one row for each symbol. datetime.now() is the time on your computer, and %H:%M:%S writes it as hours, minutes and seconds.

Line 25

Call the function once.

$ uv run --env-file .env watchlist.py Quotes at 16:15:00symbol       last   change        %AAPL       330.27    +3.47   +1.06%MSFT       522.48    -2.62   -0.50%NVDA       185.12    +2.17   +1.19%SPY        771.53    +4.33   +0.56%QQQ        752.11    +3.21   +0.43%

Step 3 Refresh every minute

"""A watchlist: the latest quotes for a few symbols, refreshed every minute. Run it, and press Ctrl+C to stop:     uv run --env-file .env watchlist.py""" import timefrom datetime import datetime from quote import get_snapshots SYMBOLS = ["AAPL", "MSFT", "NVDA", "SPY", "QQQ"]REFRESH_SECONDS = 60  def row(symbol, snapshot):    """One table row: symbol, last price, and change since the previous close."""    last = snapshot["latestTrade"]["p"]    previous = snapshot["prevDailyBar"]["c"]    change = last - previous    return f"{symbol:<6} {last:>10.2f} {change:>+8.2f} {change / previous:>+8.2%}"  def show(symbols):    """Print the time, a header, then one row per symbol, from one request."""    snapshots = get_snapshots(symbols)    print(f"\nQuotes at {datetime.now():%H:%M:%S}")    print(f"{'symbol':<6} {'last':>10} {'change':>8} {'%':>8}")    for symbol in symbols:        print(row(symbol, snapshots[symbol]))  if __name__ == "__main__":    try:        while True:            show(SYMBOLS)            time.sleep(REFRESH_SECONDS)    except KeyboardInterrupt:        print("\nStopped.")

Line 14

How long to wait between tables, in seconds.

Lines 36 to 38

while True repeats forever: show the table, then wait with time.sleep.

Lines 39 to 40

Ctrl+C stops a running program by raising a KeyboardInterrupt. try and except catch it, so the program says Stopped instead of printing an error.

$ uv run --env-file .env watchlist.py Quotes at 16:15:00symbol       last   change        %AAPL       330.27    +3.47   +1.06%MSFT       522.48    -2.62   -0.50%NVDA       185.12    +2.17   +1.19%SPY        771.53    +4.33   +0.56%QQQ        752.11    +3.21   +0.43% Stopped.

It prints a new table every minute until you press Ctrl+C; here it was stopped after the first. One request a minute is plenty for prices 15 minutes behind: asking faster gains nothing, and Alpaca’s free plan allows 200 requests a minute across everything you run.

Step 1 See what Git sees

In the market-data folder, ask Git what it sees:

$ git statusOn branch main No commits yet Untracked files:  (use "git add <file>..." to include in what will be committed)	.env.example	.gitignore	.python-version	README.md	pyproject.toml	quote.py	uv.lock	watchlist.py nothing added to commit but untracked files present (use "git add" to track)

uv init already started a Git repository, the folder’s history, on the main branch. Every file is untracked: Git sees it but holds no version of it yet. .venv and .env are missing from the list because .gitignore names them, while .env.example is there to be committed.

Step 2 Save your first version

$ git add .$ git commit -m "Print a quote and a watchlist"[main (root-commit) c824e2b] Print a quote and a watchlist 8 files changed, 211 insertions(+) create mode 100644 .env.example create mode 100644 .gitignore create mode 100644 .python-version create mode 100644 README.md create mode 100644 pyproject.toml create mode 100644 quote.py create mode 100644 uv.lock create mode 100644 watchlist.py$ git log --onelinec824e2b Print a quote and a watchlist

git add . stages every file in the folder that .gitignore doesn’t name; the dot means this folder. The message says what the commit does. git log --oneline shows the commit with its id; yours will differ.

Step 3 Change a file, and save the change

Add "AMZN", Amazon, to the list in watchlist.py and save the file. Then look at the change and commit it:

$ git status --short M watchlist.py$ git diffdiff --git a/watchlist.py b/watchlist.pyindex 8f7cfde..b1fc4a9 100644--- a/watchlist.py+++ b/watchlist.py@@ -10,7 +10,7 @@ from datetime import datetime  from quote import get_snapshots -SYMBOLS = ["AAPL", "MSFT", "NVDA", "SPY", "QQQ"]+SYMBOLS = ["AAPL", "MSFT", "NVDA", "AMZN", "SPY", "QQQ"] REFRESH_SECONDS = 60  $ git commit -am "Add Amazon to the watchlist"[main eb65bbe] Add Amazon to the watchlist 1 file changed, 1 insertion(+), 1 deletion(-)$ git log --onelineeb65bbe Add Amazon to the watchlistc824e2b Print a quote and a watchlist

git status --short marks the changed file with M, for modified. git diff shows the old line with − and the new one with +. git commit -am stages every changed file Git already tracks, and commits it, in one step.

Step 4 Throw a change away

Now change REFRESH_SECONDS to 6, save, and then change your mind:

$ git diffdiff --git a/watchlist.py b/watchlist.pyindex b1fc4a9..391e73f 100644--- a/watchlist.py+++ b/watchlist.py@@ -11,7 +11,7 @@ from datetime import datetime from quote import get_snapshots  SYMBOLS = ["AAPL", "MSFT", "NVDA", "AMZN", "SPY", "QQQ"]-REFRESH_SECONDS = 60+REFRESH_SECONDS = 6   def row(symbol, snapshot):$ git restore watchlist.py$ git statusOn branch mainnothing to commit, working tree clean

git restore put watchlist.py back as it was at the last commit, so git status has nothing to report.

Step 5 Undo a commit

Say adding Amazon was a mistake. Look at the commit, then revert it:

$ git show --stat HEADcommit eb65bbecf372bc64b69cb17201e41232b8f6fd36Author: Your Name <[email protected]>Date:   Wed Oct 7 19:22:20 2026 +0000     Add Amazon to the watchlist  watchlist.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)$ git revert --no-edit HEAD[main dfb8805] Revert "Add Amazon to the watchlist" Date: Wed Oct 7 19:22:20 2026 +0000 1 file changed, 1 insertion(+), 1 deletion(-)$ git log --onelinedfb8805 Revert "Add Amazon to the watchlist"eb65bbe Add Amazon to the watchlistc824e2b Print a quote and a watchlist

git show --stat HEAD shows the newest commit and which files it changed. git revert makes a new commit that takes Amazon back out. The log keeps all three commits: the first version, the change, and its undoing.