VWAP explained: formula, calculation and Python code on live data

import os
from datetime import datetime
from zoneinfo import ZoneInfo

import requests  # pip install requests

API = "https://api.tickerlayer.com"
HEADERS = {"x-api-key": os.environ["TICKERLAYER_API_KEY"]}
NEW_YORK = ZoneInfo("America/New_York")


def minute_bars(symbol, day):
    """Regular-session 1-minute bars for one date, oldest first."""
    url = f"{API}/stocks/agg/{symbol}/1/minute/{day}/{day}"
    params = {"sort": "asc", "limit": 5000, "offset": 0}
    bars = []
    while True:
        resp = requests.get(url, params=params, headers=HEADERS, timeout=15)
        resp.raise_for_status()
        body = resp.json()
        bars.extend(body["results"])
        if body.get("next_offset") is None:
            return bars
        params["offset"] = body["next_offset"]


def running_vwap(bars):
    """Yield (bar, VWAP so far), using each bar's typical price."""
    pv = volume = 0.0
    for bar in bars:
        typical = (bar["h"] + bar["l"] + bar["c"]) / 3
        pv += typical * bar["v"]
        volume += bar["v"]
        yield bar, pv / volume


bars = minute_bars("US:KO", "2026-09-25")
rows = list(running_vwap(bars))
for bar, vwap in rows[::60] + rows[-1:]:
    at = datetime.fromtimestamp(bar["t"] / 1000, NEW_YORK).strftime("%H:%M")
    side = "above" if bar["c"] > vwap else "below"
    print(f"{at} ET  close {bar['c']:7.3f}  VWAP {vwap:7.3f}  ({side})")
print(f"{len(bars)} bars, {sum(b['v'] for b in bars):,} shares")

09:30 ET  close  88.060  VWAP  88.104  (below)
10:30 ET  close  87.840  VWAP  87.859  (below)
11:30 ET  close  87.835  VWAP  87.843  (below)
12:30 ET  close  88.025  VWAP  87.859  (above)
13:30 ET  close  88.100  VWAP  87.882  (above)
14:30 ET  close  87.635  VWAP  87.877  (below)
15:30 ET  close  87.660  VWAP  87.834  (below)
15:59 ET  close  87.810  VWAP  87.832  (below)
390 bars, 8,997,796 shares

import asyncio
import json
import os
import time
from datetime import datetime
from urllib.parse import quote
from zoneinfo import ZoneInfo

import requests
import websockets  # pip install websockets requests

API = "https://api.tickerlayer.com"
KEY = os.environ["TICKERLAYER_API_KEY"]
STREAM = "wss://stream.tickerlayer.com/?apiKey=" + quote(KEY, safe="")
NEW_YORK = ZoneInfo("America/New_York")
SYMBOL = "US:KO"


class SessionVwap:
    """Running VWAP over 1-minute bars that starts again on each New York trading day."""

    def __init__(self):
        self.session, self.pv, self.volume, self.seen = None, 0.0, 0.0, set()

    def add_bar(self, bar_start_ms, price, volume):
        session = datetime.fromtimestamp(bar_start_ms / 1000, NEW_YORK).date()
        if session != self.session:  # new day: reset
            self.session, self.pv, self.volume, self.seen = session, 0.0, 0.0, set()
        if bar_start_ms not in self.seen:  # REST backfill and stream may overlap
            self.seen.add(bar_start_ms)
            self.pv += price * volume
            self.volume += volume
        return self.pv / self.volume if self.volume else None


def backfill(vwap):
    """Closed regular-session minutes so far today. REST bars carry no vw: use typical price."""
    today = datetime.now(NEW_YORK).date().isoformat()
    resp = requests.get(f"{API}/stocks/agg/{SYMBOL}/1/minute/{today}/{today}",
                        params={"sort": "asc", "limit": 5000}, headers={"x-api-key": KEY}, timeout=15)
    resp.raise_for_status()
    forming = int(time.time()) // 60 * 60_000
    for bar in resp.json()["results"]:
        if bar["t"] < forming:
            vwap.add_bar(bar["t"], (bar["h"] + bar["l"] + bar["c"]) / 3, bar["v"])


async def main():
    vwap = SessionVwap()
    async with websockets.connect(STREAM, compression=None, open_timeout=10) as ws:
        await ws.recv()  # {"type":"system","event":"ready",...}
        await ws.send(json.dumps({"action": "subscribe", "channels": ["stocks.agg"],
                                  "symbols": [SYMBOL], "interval": "1m", "session": "regular"}))
        await asyncio.to_thread(backfill, vwap)  # subscribe first, so no minute falls in a gap
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") != "agg":
                continue
            price = msg.get("vw") or (msg["h"] + msg["l"] + msg["c"]) / 3  # vw can be omitted
            value = vwap.add_bar(msg["ts"], price, msg["v"])
            at = datetime.fromtimestamp(msg["ts"] / 1000, NEW_YORK).strftime("%H:%M")
            print(f"{at} {SYMBOL} close {msg['c']:.2f}  bar vw {price:.4f}  session VWAP {value:.4f}")


if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import json
import os
from urllib.parse import quote

import websockets  # pip install websockets

URL = "wss://stream.tickerlayer.com/?apiKey=" + quote(os.environ["TICKERLAYER_API_KEY"], safe="")
DAY_MS = 86_400_000


async def main():
    day, pv, volume, n = None, 0.0, 0.0, 0
    async with websockets.connect(URL, compression=None, open_timeout=10) as ws:
        await ws.recv()  # {"type":"system","event":"ready",...}
        await ws.send(json.dumps({"action": "subscribe", "channels": ["crypto.trades"], "symbols": ["BTCUSD"]}))
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") != "trade":
                continue
            price, size = float(msg["price"]), float(msg["size"])  # strings; size can be "3e-8"
            if msg["ts"] // DAY_MS != day:  # a new UTC day starts a new VWAP
                day, pv, volume = msg["ts"] // DAY_MS, 0.0, 0.0
            pv += price * size
            volume += size
            n += 1
            if n % 100 == 0:
                print(f"BTCUSD last {price:,.2f}  VWAP since connect {pv / volume:,.2f}  on {volume:.4f} BTC")


if __name__ == "__main__":
    asyncio.run(main())