Current and historical token price data with multi-chain support for portfolio valuation and analytics. The Prices namespace provides comprehensive price data for tokens across supported networks.
Get real-time token prices in various currencies.
/**
* Get current prices for multiple tokens
* @param params - Price query parameters
* @returns Promise resolving to current token prices
*/
getTokenPrices(params: GetTokenPricesParams): Promise<GetTokenPricesResponse>;
interface GetTokenPricesParams {
addresses: string[];
currency?: string;
network?: Network;
}
interface GetTokenPricesResponse {
data: TokenPrice[];
currency: string;
network: Network;
}
interface TokenPrice {
address: string;
symbol: string;
name: string;
logo?: string;
decimals: number;
price: number;
priceChange24h?: number;
priceChangePercentage24h?: number;
marketCap?: number;
volume24h?: number;
lastUpdated: string;
}Query historical price data for analysis and charting.
/**
* Get historical price data for tokens
* @param params - Historical price query parameters
* @returns Promise resolving to historical price data
*/
getHistoricalPrices(params: GetHistoricalPricesParams): Promise<GetHistoricalPricesResponse>;
interface GetHistoricalPricesParams {
addresses: string[];
currency?: string;
network?: Network;
startTime: number; // Unix timestamp
endTime?: number; // Unix timestamp
interval?: PriceInterval;
}
interface GetHistoricalPricesResponse {
data: HistoricalTokenPrice[];
currency: string;
network: Network;
interval: PriceInterval;
}
interface HistoricalTokenPrice {
address: string;
symbol: string;
name: string;
prices: PricePoint[];
}
interface PricePoint {
timestamp: number;
price: number;
volume?: number;
marketCap?: number;
}
enum PriceInterval {
HOURLY = "1h",
DAILY = "1d",
WEEKLY = "1w",
MONTHLY = "1m",
}Set up price alerts and monitoring for tokens.
/**
* Create a price alert for a token
* @param params - Price alert parameters
* @returns Promise resolving to created alert
*/
createPriceAlert(params: CreatePriceAlertParams): Promise<PriceAlert>;
/**
* Get all active price alerts
* @returns Promise resolving to array of active alerts
*/
getPriceAlerts(): Promise<PriceAlert[]>;
/**
* Update a price alert
* @param alertId - Alert ID to update
* @param params - Updated alert parameters
* @returns Promise resolving to void
*/
updatePriceAlert(alertId: string, params: UpdatePriceAlertParams): Promise<void>;
/**
* Delete a price alert
* @param alertId - Alert ID to delete
* @returns Promise resolving to void
*/
deletePriceAlert(alertId: string): Promise<void>;
interface CreatePriceAlertParams {
address: string;
network: Network;
condition: PriceCondition;
targetPrice: number;
currency?: string;
webhookUrl?: string;
}
interface PriceAlert {
id: string;
address: string;
network: Network;
condition: PriceCondition;
targetPrice: number;
currentPrice: number;
currency: string;
isActive: boolean;
createdAt: string;
webhookUrl?: string;
}
interface UpdatePriceAlertParams {
condition?: PriceCondition;
targetPrice?: number;
isActive?: boolean;
webhookUrl?: string;
}
enum PriceCondition {
ABOVE = "above",
BELOW = "below",
CHANGE_PERCENT = "change_percent",
}Get comprehensive market data and statistics.
/**
* Get market summary for tokens
* @param addresses - Token addresses to get market data for
* @param currency - Currency for price data
* @returns Promise resolving to market summaries
*/
getMarketSummary(
addresses: string[],
currency?: string
): Promise<MarketSummaryResponse>;
/**
* Get top tokens by market cap
* @param params - Query parameters
* @returns Promise resolving to top tokens
*/
getTopTokens(params?: GetTopTokensParams): Promise<GetTopTokensResponse>;
/**
* Get trending tokens
* @param network - Network to get trending tokens for
* @param timeframe - Timeframe for trending analysis
* @returns Promise resolving to trending tokens
*/
getTrendingTokens(
network?: Network,
timeframe?: TrendingTimeframe
): Promise<GetTrendingTokensResponse>;
interface MarketSummaryResponse {
data: MarketSummary[];
currency: string;
}
interface MarketSummary {
address: string;
symbol: string;
name: string;
price: number;
marketCap: number;
volume24h: number;
priceChange24h: number;
priceChangePercentage24h: number;
high24h: number;
low24h: number;
ath: number;
athDate: string;
atl: number;
atlDate: string;
}
interface GetTopTokensParams {
network?: Network;
currency?: string;
limit?: number;
offset?: number;
}
interface GetTopTokensResponse {
data: MarketSummary[];
total: number;
currency: string;
network: Network;
}
interface GetTrendingTokensResponse {
data: TrendingToken[];
timeframe: TrendingTimeframe;
network: Network;
}
interface TrendingToken {
address: string;
symbol: string;
name: string;
price: number;
priceChangePercentage: number;
volume24h: number;
trendingScore: number;
}
enum TrendingTimeframe {
HOUR = "1h",
DAY = "24h",
WEEK = "7d",
}Manage custom price feeds and data sources.
/**
* Get available price feed sources
* @returns Promise resolving to available sources
*/
getPriceFeedSources(): Promise<PriceFeedSource[]>;
/**
* Configure custom price feed
* @param params - Price feed configuration
* @returns Promise resolving to feed configuration
*/
configurePriceFeed(params: PriceFeedConfig): Promise<PriceFeed>;
/**
* Get price feed status and health
* @param feedId - Price feed ID
* @returns Promise resolving to feed status
*/
getPriceFeedStatus(feedId: string): Promise<PriceFeedStatus>;
interface PriceFeedSource {
id: string;
name: string;
description: string;
supportedNetworks: Network[];
updateFrequency: number; // seconds
reliability: number; // 0-1 score
}
interface PriceFeedConfig {
sources: string[];
updateInterval: number;
failoverEnabled: boolean;
aggregationMethod: AggregationMethod;
}
interface PriceFeed {
id: string;
sources: PriceFeedSource[];
config: PriceFeedConfig;
status: PriceFeedStatus;
}
interface PriceFeedStatus {
isActive: boolean;
lastUpdate: string;
successRate: number;
latency: number;
errors: string[];
}
enum AggregationMethod {
AVERAGE = "average",
MEDIAN = "median",
WEIGHTED_AVERAGE = "weighted_average",
}Usage Examples:
import { Alchemy, Network, PriceInterval } from "alchemy-sdk";
const alchemy = new Alchemy({
apiKey: "your-api-key",
network: Network.ETH_MAINNET,
});
// Get current prices for multiple tokens
const currentPrices = await alchemy.prices.getTokenPrices({
addresses: [
"0xA0b86a33E6441E368a55a6F5e8C1112b618F10f1", // WETH
"0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
],
currency: "USD",
});
console.log("Current prices:", currentPrices.data);
// Get historical price data for charting
const historicalPrices = await alchemy.prices.getHistoricalPrices({
addresses: ["0xA0b86a33E6441E368a55a6F5e8C1112b618F10f1"],
currency: "USD",
startTime: Date.now() - (7 * 24 * 60 * 60 * 1000), // 7 days ago
endTime: Date.now(),
interval: PriceInterval.DAILY,
});
// Create price alert
const alert = await alchemy.prices.createPriceAlert({
address: "0xA0b86a33E6441E368a55a6F5e8C1112b618F10f1",
network: Network.ETH_MAINNET,
condition: PriceCondition.ABOVE,
targetPrice: 4000,
currency: "USD",
webhookUrl: "https://your-server.com/price-alert",
});
// Get market summary
const marketData = await alchemy.prices.getMarketSummary([
"0xA0b86a33E6441E368a55a6F5e8C1112b618F10f1",
"0xdAC17F958D2ee523a2206206994597C13D831ec7",
], "USD");
console.log("Market cap:", marketData.data[0].marketCap);
console.log("24h volume:", marketData.data[0].volume24h);
// Get top tokens by market cap
const topTokens = await alchemy.prices.getTopTokens({
network: Network.ETH_MAINNET,
currency: "USD",
limit: 10,
});
// Get trending tokens
const trending = await alchemy.prices.getTrendingTokens(
Network.ETH_MAINNET,
TrendingTimeframe.DAY
);
console.log("Trending tokens:", trending.data);
// Configure custom price feed
const priceFeed = await alchemy.prices.configurePriceFeed({
sources: ["coingecko", "coinmarketcap"],
updateInterval: 60, // 1 minute
failoverEnabled: true,
aggregationMethod: AggregationMethod.MEDIAN,
});