Market Profile (TPO)

Market Profile organizes a session’s trade into Time Price Opportunities (TPOs): the session is split into fixed-length time periods (one letter each), and every price a period traded at earns that letter. Stacking the letters sideways draws a distribution that shows where the market spent its time - the fat middle is acceptance, the thin edges are rejection.

It is two pieces: computeMarketProfile (pure analytics, in the profile tier) and the MarketProfile primitive that renders the result on the chart.

import { computeMarketProfile, MarketProfile } from 'openalgo-charts/profile';
 
const result = computeMarketProfile(bars, { tickSize: 0.05, session: 'day', blockMinutes: 30 });
chart.addPrimitive(new MarketProfile(result));

Concepts

• Session - how bars are grouped into profiles: day, week, month, or composite (one profile over everything). Grouping is by the IST calendar.
• Period / letter - each blockMinutes slice of a session is one TPO letter (A, B, … Z, then a..z).
• POC - Point of Control, the price with the most TPOs (the longest row).
• Value Area (VAH / VAL) - the band around the POC holding valueAreaPercent of all TPOs.
• Initial Balance - the price range of the opening initialBalancePeriods periods.
• Single prints - lone TPOs away from the extremes (quick moves that left a gap in time).
• Poor high / low - a session extreme printed by more than one TPO (a weak, often revisited, edge).

A profile in a few lines

The renderer overlays the price series, so add a price series first (it provides the time axis). Here is a composite profile - one distribution over all the bars, letters packed from the left:

const chart = lib.createChart(el);
const bars = lib.generateBars(1700000000, 26, 1800); // 30-min bars
chart.addSeries('candlestick').setData(bars);

const mp = lib.computeMarketProfile(bars, { tickSize: 1, session: 'composite', blockMinutes: 30 });
chart.addPrimitive(new lib.MarketProfile(mp));

chart.timeScale.fitContent(bars.length);
return chart;

Sessions

Switch session to split the same bars into one profile per day / week / month. Each session’s profile is drawn under its own bars, so you can read structure across time:

const chart = lib.createChart(el);
const bars = lib.generateBars(1700000000, 120, 1800);
chart.addSeries('candlestick').setData(bars);

const mp = lib.computeMarketProfile(bars, { tickSize: 1, session: 'day', blockMinutes: 60, valueAreaPercent: 0.7 });
chart.addPrimitive(new lib.MarketProfile(mp)); // IB bracket on the left of each session

chart.timeScale.fitContent(bars.length);
return chart;

Color modes & volume sub-profile

colorMode is valueArea (default), uniform, or heat (opacity scales with TPO count). Turn letters off for a solid histogram, and overlay a volume-at-price sub-profile:

const chart = lib.createChart(el);
const bars = lib.generateBars(1700000000, 40, 1800);
chart.addSeries('candlestick').setData(bars);

const mp = lib.computeMarketProfile(bars, { tickSize: 1, session: 'composite', blockMinutes: 30 });
chart.addPrimitive(new lib.MarketProfile(mp, {
colorMode: 'heat',
showLetters: false,        // solid blocks instead of letters
showVolumeProfile: true,   // volume-at-price on the right edge
volumeProfileWidth: 70,
}));

chart.timeScale.fitContent(bars.length);
return chart;

computeMarketProfile options

computeMarketProfile(bars, options): MarketProfileResult

Row size

TPO row height is tickSize * rowTicks. Keeping the two separate means widening rows never means lying about the instrument’s tick — which matters, because the tick is what imbalance and single-print logic are counted on.

rowTicks is the multiplier a trader already thinks in. Nifty trades in 0.1 and you want 2-point rows, so the multiplier is 2 / 0.1 = 20:

computeMarketProfile(bars, { tickSize: 0.1, rowTicks: 20 });      // 2-point rows
computeMarketProfile(bars, { tickSize: 0.1, rowTicks: rowTicksFor(2, 0.1) });  // same thing

rowTicksFor(rowSize, tickSize) does the division for you and floors at 1.

Session windows

A window drops bars outside a trading session and anchors period A to the window’s open — not to whatever bar happened to arrive first, which otherwise shifts every letter. Windows that cross midnight are handled as one session, not two halves.

import { computeMarketProfile, TRADING_HOURS } from 'openalgo-charts/profile';
 
computeMarketProfile(bars, { window: TRADING_HOURS['india'] });          // 09:15–15:30 IST
computeMarketProfile(bars, { window: { startMinute: 9 * 60 + 15, endMinute: 15 * 60 + 30, name: 'RTH' } });

Built-ins: all-hours, india, asia, london, new-york, us-regular — all in IST minutes-from-midnight, since the library’s calendar is IST (§5.3).

MarketProfile primitive options

Pass in the constructor (new MarketProfile(result, options)) or update live with profile.setOptions({ ... }).

Letters and bricks

A TPO row is only as tall as the price scale makes it, so at some zoom a letter stops fitting. Rather than clip glyphs or make you toggle a setting, blockDisplay: 'auto' (the default) crossfades: the block is always drawn, and the letter fades in over letterFade px above minLetterHeight. Zooming through the threshold reads as one continuous change rather than a jump, and the profile stays readable at every scale.

Pin the behaviour when you want it fixed — 'letters' for glyphs only, 'blocks' for a pure brick profile, 'blocks+letters' to force both regardless of room.

Hit-testing

hitTest(x, y) and hoverAt(x, y) map a pointer back to the session and price row under it, so a host can build a tooltip without the library owning any DOM. hoverAt returns { sessionIndex, price, level, session, isPoc, inValueArea, isSinglePrint }.

chart.on('crosshair:move', (e) => {
  const hit = e.point ? mp.hoverAt(e.point.x, e.point.y) : null;
  if (hit) tooltip.textContent = `${hit.level.letters}  ${hit.level.count} TPO`;
});

Data model

interface MarketProfileResult {
  sessions: MarketProfileSessionResult[];
  options: MarketProfileOptions;
}
 
interface MarketProfileSessionResult {
  startTime: number;      // UTC seconds (first bar)
  endTime: number;        // UTC seconds (last bar)
  levels: { price: number; count: number; letters: string; volume: number }[]; // high -> low
  poc: number;
  vah: number; val: number;
  periods: number;
  initialBalance: { high: number; low: number };
  singlePrints: number[];
  poorHigh: boolean; poorLow: boolean;
  totalVolume: number;
}

Everything you need for your own annotations (naked POCs, day-type labels, alerts) is on the result - the primitive is just one way to draw it.

Live updates

Recompute on new bars and hand the fresh result to the same primitive; setData repaints:

const profile = new MarketProfile(computeMarketProfile(bars, opts));
chart.addPrimitive(profile);
 
// later, as bars grow:
profile.setData(computeMarketProfile(bars, opts));
profile.setOptions({ colorMode: 'heat' }); // restyle without recomputing

Troubleshooting