Stock Price Generator

Generates random number for synthetic stock price data using various random algorithm models. The generated data can be used for testing and simulation purposes.

Features

• Generate one-time stock price arrays
• Create continuous stock price generators with configurable intervals
• Support for various random algorithms (Random Walk, GBM, etc.)
• Configurable parameters for volatility, drift, and more
• Track both the current and previous price via getPreviousPrice() / result.previousPrice / the onPrice callback
• Support for both ES Modules (import/export), CommonJS (require), and TypeScript

Requirements

• Node.js 22.x or 24.x (active/maintenance LTS releases)

Installation

# Using npm
npm install stockprice-generator

Usage

Check github for more example usages

CommonJS

const { getStockPrices, getContStockPrices } = require('stockprice-generator');

// Generate an array of stock prices
const result = getContStockPrices({
    startPrice: 10000,
    length: 100,
    volatility: 0.1,
    drift: 0.05,
    algorithm: 'RandomWalk'
});

console.log(result.data); // Array of prices
console.log(result.price); // Current price (last price in the array)

ES Modules

import { getStockPrices, getContStockPrices } from 'stockprice-generator';

// Generate an array of stock prices
const result = getStockPrices({
    startPrice: 10000,
    length: 100,
    volatility: 0.1,
    drift: 0.05,
    algorithm: 'RandomWalk'
});

console.log(result.data); // Array of prices
console.log(result.price); // Current price (last price in the array)

Continuous Generation (CommonJS)

const { getContStockPrices } = require('stockprice-generator');

// Create a continuous generator that emits prices every 60 seconds
const generator = getContStockPrices({
    startPrice: 10000,
    volatility: 0.1,
    drift: 0.05,
    algorithm: 'RandomWalk',
    interval: 60000, // 60 seconds
    onPrice: (price, previousPrice) => {
        console.log(`New price: ${price} (was ${previousPrice})`);
    }
});

// Start the generator
generator.start();

// Get the current and previous price
console.log(`Current price: ${generator.getCurrentPrice()}`);
console.log(`Previous price: ${generator.getPreviousPrice()}`);

// Stop the generator when done
// generator.stop();

Continuous Generation (ES Modules)

import { getStockPrices } from 'stockprice-generator';

// Create a continuous generator that emits prices every 60 seconds
const generator = getStockPrices({
    startPrice: 10000,
    volatility: 0.1,
    drift: 0.05,
    algorithm: 'RandomWalk',
    interval: 60000, // 60 seconds
    onPrice: (price: number, previousPrice: number | null) => {
        console.log(`New price: ${price} (was ${previousPrice})`);
    }
});

// Start the generator
generator.start();

// Get the current and previous price
console.log(`Current price: ${generator.getCurrentPrice()}`);
console.log(`Previous price: ${generator.getPreviousPrice()}`);

// Stop the generator when done
// generator.stop();

Examples

Bounded price walk (min/max)

import { getStockPrices } from 'stockprice-generator';

// Price is kept within [9000, 11000] for the whole series
const result = getStockPrices({
    startPrice: 10000,
    length: 100,
    min: 9000,
    max: 11000
});

GBM with delisting

import { getStockPrices } from 'stockprice-generator';

// If the price collapses to a near-zero threshold, it is forced to (and stays at) 0
const result = getStockPrices({
    startPrice: 100,
    length: 250,
    algorithm: 'GBM',
    drift: -2,
    volatility: 1.5,
    delisting: true
});

Reproducible series with a seed

import { getStockPrices } from 'stockprice-generator';

// Same seed always produces the same series
const a = getStockPrices({ startPrice: 10000, length: 50, seed: 42 });
const b = getStockPrices({ startPrice: 10000, length: 50, seed: 42 });
// a.data and b.data are identical

Mean-reverting series (OU)

import { getStockPrices } from 'stockprice-generator';

// The price drifts back toward longTermMean instead of wandering freely
const result = getStockPrices({
    startPrice: 10000,
    length: 250,
    algorithm: 'OU',
    longTermMean: 9500,
    reversionSpeed: 0.5,
    volatility: 0.2
});

Jump-diffusion series (sudden spikes/crashes)

import { getStockPrices } from 'stockprice-generator';

// Standard GBM diffusion plus occasional jumps
const result = getStockPrices({
    startPrice: 10000,
    length: 250,
    algorithm: 'JumpDiffusion',
    jumpIntensity: 5,
    jumpMean: 0,
    jumpVolatility: 0.3
});

Discretized integer prices (step + dataType)

import { getStockPrices } from 'stockprice-generator';

// Prices are rounded to the nearest multiple of 50 and returned as integers
const result = getStockPrices({
    startPrice: 10000,
    length: 100,
    step: 50,
    dataType: 'int'
});

Parameters

Parameter	Required	Type	Default	Description
startPrice	Yes	number	-	Initial price of the stock
length	No	number	100	Length of the output array
volatility	No	number	0.1	Volatility of the stock price (standard deviation of the returns)
drift	No	number	0.05	The drift of the stock price (mean of the returns)
seed	No	number	DateTime	Seed for random number generation (for reproducibility)
min	No	number	0	Minimum price for the stock (0 = unlimited)
max	No	number	0	Maximum price for the stock (0 = unlimited)
delisting	No	boolean	false	Force the price to 0 once it falls to or below a near-zero threshold
step	No	number	-	Step size for discretization
dataType	No	float | int	float	Type of the output data type
algorithm	No	RandomWalk | GBM | OU | JumpDiffusion	RandomWalk	Algorithm for generating the random number
longTermMean	No	number	startPrice	OU only: the level the price reverts toward
reversionSpeed	No	number	0.15	OU only: how strongly the price is pulled back toward longTermMean
jumpIntensity	No	number	1	JumpDiffusion only: expected number of jumps per year
jumpMean	No	number	0	JumpDiffusion only: mean log-size of a jump
jumpVolatility	No	number	0.1	JumpDiffusion only: volatility of the jump log-size

min and max only take effect when at least one of them is non-zero; leaving both at the default 0 means no bounds are enforced.

Algorithms

• RandomWalk: simple random walk with drift and volatility
• GBM: Geometric Brownian Motion, the standard continuous-time model for stock prices
• OU: Ornstein-Uhlenbeck, a mean-reverting model that pulls the price back toward longTermMean
• JumpDiffusion: Merton jump-diffusion — GBM plus occasional Poisson-driven jumps for spikes/crashes

Handler Functions (only for continuous generation)

Parameter	Required	Type	Default	Description
interval	Yes	number	60000	Interval in milliseconds between price updates in continuous generation
onStart	No	function	-	Callback function to handle generator start event
onPrice	No	(price: number, previousPrice: number | null) => void	-	Callback function to handle new prices in continuous generation. previousPrice is null on the very first tick
onStop	No	function	-	Callback function to handle generator stop event
onComplete	No	function	-	Callback function to handle generator completion event
onError	No	function	-	Callback function to handle errors in continuous generation

Contributing

See CONTRIBUTING.md for branch naming, commit message conventions, and the release process.

Security

This project has no runtime dependencies, and development dependencies are kept up to date and regularly audited with npm audit. If you discover a security issue, please open an issue on GitHub.

License

MIT