TradingView Data Source

Introduction

This is a data source library for algorithmic trading written in Rust inspired by TradingView-API. It provides programmatic access to TradingView's data and features through a robust, async-first API.

The library exposes two usage tiers:

• High-level — An event-driven DataLoader that connects a source to multiple sinks with backpressure and graceful shutdown.
• Low-level — Direct access to HTTP clients, WebSocket sessions, and raw message parsing for full control.

Status: tradingview-rs is a stable community data source library under active development. Note that it is an unofficial integration subject to upstream TradingView changes; review version notes and test against your workload before deploying to production.

Features

• Async Support — Built with Tokio for high-performance async operations
• Event-Driven Pipeline — DataSource → fan-out → EventSink architecture with bounded channels, cancellation tokens, and error recovery
• Multiple Sinks — Built-in channel, callback, and Kafka (RedPanda) sinks; implement your own via the EventSink trait
• Real-time Data — WebSocket-based live market data with automatic reconnection and circuit breaker
• Historical Data — Fetch OHLCV data for single symbols and concurrent batch operations
• Session Management — Shared sessions between threads to respect TradingView's rate limits
• Custom Indicators — Work with Pine Script indicators via study configurations
• Chart Drawings — Retrieve your chart drawings and annotations
• Replay Mode — Historical market replay functionality
• Symbol Search — Search and filter symbols by market, country, and type
• News Integration — Access TradingView news and headlines
• User Authentication — Login with username/password + TOTP 2FA support
• Premium Features — Access TradingView Pro/Premium/Expert data tiers
• Fundamental data — Built-in Pine study catalog & date-versioned registry (tradingview::fundamental)
• Technical analysis signals — Retrieve scanner ratings across 8 timeframes (via get_technical_analysis)
• Invite-only indicators support — Access private Pine Script indicators (via get_private_indicators)
• Public chat interactions
• Screener integration
• Economic calendar — Global macroeconomic events endpoint (tradingview::client::fin_calendar)
• Vectorized data conversion

Installation

Add this to your Cargo.toml:

[dependencies]
# From crates.io (recommended):
tradingview-rs = "0.3"

# Or from the Git repository:
tradingview-rs = { git = "https://github.com/bitbytelabio/tradingview-rs.git", branch = "main" }

Feature Flags

Example with optional features:

[dependencies]
tradingview-rs = { version = "0.3", default-features = false, features = ["native-tls", "user"] }

Quick Start

Historical Data (Single Symbol)

use tradingview::{DataServer, Interval, history};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let auth_token = std::env::var("TV_AUTH_TOKEN").expect("TV_AUTH_TOKEN is not set");

    let (_info, data) = history::single::retrieve()
        .auth_token(&auth_token)
        .symbol("BTCUSDT")
        .exchange("BINANCE")
        .interval(Interval::OneHour)
        .with_replay(true)
        .server(DataServer::ProData)
        .call()
        .await?;

    println!("Retrieved {} data points", data.len());
    Ok(())
}

Historical Data (Batch)

use tradingview::{Interval, Symbol, history};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let auth_token = std::env::var("TV_AUTH_TOKEN").expect("TV_AUTH_TOKEN is not set");

    let symbols = vec![
        Symbol::builder().symbol("BTCUSDT").exchange("BINANCE").build(),
        Symbol::builder().symbol("ETHUSDT").exchange("BINANCE").build(),
    ];

    let datamap = history::batch::retrieve()
        .auth_token(&auth_token)
        .symbols(&symbols)
        .interval(Interval::OneHour)
        .call()
        .await?;

    for (symbol_info, ticker_data) in datamap.values() {
        println!("{}: {} data points", symbol_info.name, ticker_data.len());
    }

    Ok(())
}

Symbol Search

use tradingview::{list_symbols, prelude::*};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let symbols = list_symbols()
        .market_type(MarketType::All)
        .call()
        .await?;

    println!("Found {} symbols", symbols.len());
    Ok(())
}

User Authentication

use tradingview::UserCookies;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let username = std::env::var("TV_USERNAME").expect("TV_USERNAME is not set");
    let password = std::env::var("TV_PASSWORD").expect("TV_PASSWORD is not set");
    let totp = std::env::var("TV_TOTP_SECRET").expect("TV_TOTP_SECRET is not set");

    let user = UserCookies::default()
        .login(&username, &password, Some(&totp))
        .await?;

    // Save cookies for later use
    let json = serde_json::to_string_pretty(&user)?;
    std::fs::write("tv_user_cookies.json", json)?;

    Ok(())
}

Real-time Data

use dotenv::dotenv;
use std::{env, sync::Arc, time::Duration};
use tokio::{sync::mpsc, time::sleep};
use tradingview::{
    ChartOptions, Interval,
    live::{
        handler::{
            command::CommandRunner,
            message::{Command, TradingViewResponse},
        },
        models::DataServer,
        websocket::WebSocketClient,
    },
};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenv().ok();

    let auth_token = env::var("TV_AUTH_TOKEN").expect("TV_AUTH_TOKEN is not set");

    // Create communication channels
    let (response_tx, mut response_rx) = mpsc::unbounded_channel();
    let (command_tx, command_rx) = mpsc::unbounded_channel();

    // Create WebSocket client
    let ws_client = WebSocketClient::builder()
        .auth_token(&auth_token)
        .server(DataServer::ProData)
        .data_tx(response_tx)
        .build()
        .await?;

    // Create command runner
    let command_runner = CommandRunner::new(command_rx, Arc::clone(&ws_client));

    // Spawn command runner
    tokio::spawn(async move {
        command_runner.run().await.unwrap();
    });

    // Handle responses
    tokio::spawn(async move {
        while let Some(response) = response_rx.recv().await {
            match response {
                TradingViewResponse::ChartData(series_info, data_points) => {
                    println!("Chart Data: {} points", data_points.len());
                }
                TradingViewResponse::QuoteData(quote) => {
                    println!("Quote: {:?}", quote);
                }
                _ => {}
            }
        }
    });

    // Set up market data
    let options = ChartOptions::builder()
        .symbol("BTCUSDT".into())
        .exchange("BINANCE".into())
        .interval(Interval::OneMinute)
        .build();

    command_tx.send(Command::set_market(options))?;
    command_tx.send(Command::add_symbol("NASDAQ:AAPL"))?;

    // Keep running
    sleep(Duration::from_secs(60)).await;

    Ok(())
}

Working with Indicators

use tradingview::{
    ChartOptions, Interval, StudyOptions,
    get_builtin_indicators,
    pine_indicator::{BuiltinIndicators, ScriptType},
};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Get built-in indicators
    let indicators = get_builtin_indicators(BuiltinIndicators::Standard).await?;

    if let Some(indicator) = indicators.first() {
        let opts = ChartOptions::builder()
            .symbol("BTCUSDT".into())
            .exchange("BINANCE".into())
            .interval(Interval::OneDay)
            .bar_count(20)
            .study_config(StudyOptions {
                script_id: (&indicator.script_id).into(),
                script_version: (&indicator.script_version).into(),
                script_type: ScriptType::IntervalScript,
            })
            .build();

        // Use opts with WebSocket client for real-time indicator data
    }

    Ok(())
}

Full Fundamental Data With One Stock Code

use tradingview::fundamental::{FullFundamentalResult, fetch_full_fundamentals};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Bare tickers are resolved through TradingView's ranked stock search.
    // Canonical values such as "HOSE:FPT" or "TWSE:2330" are also accepted.
    let result: FullFundamentalResult = fetch_full_fundamentals("AAPL").await?;

    println!("{}: {} studies", result.canonical_id(), result.total_studies());
    println!(
        "success={}, empty={}, errors={}",
        result.success_count(),
        result.empty_count(),
        result.error_count()
    );

    // Optional lossless long-form CSV export from the returned struct.
    result.write_csv("AAPL_fundamentals.csv")?;
    Ok(())
}

The returned FullFundamentalResult owns the resolved stock metadata, registry date/schema version, and every metric result as Success(Vec<DataPoint>), Empty, or Error(String). The full stock catalog excludes crypto-only STD;CryptoFund_* studies.

Run the example with one stock code:

cargo run --example full_fundamental_fetch -- AAPL
cargo run --example full_fundamental_fetch -- HOSE:FPT
cargo run --example full_fundamental_fetch -- TWSE:2330

Economic Calendar

use chrono::{Duration, Utc};
use tradingview::client::fin_calendar::{
    EconomicCalendarRequest, EconomicImportance, get_economic_calendar,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let now = Utc::now();
    let request = EconomicCalendarRequest::builder()
        .from(now)
        .to(now + Duration::days(7))
        .countries(vec!["US".to_string(), "DE".to_string()])
        .min_importance(EconomicImportance::Medium)
        .build();

    let events = get_economic_calendar(&request).await?;
    for event in events {
        println!("{}: {} (importance: {:?})", event.date, event.title, event.importance_level());
    }
    Ok(())
}

Examples

The examples/ directory contains runnable examples for every major feature:

Run an example:

cargo run --example historical_data_fetch
cargo run --example live_quote
cargo run --example channel_consumer
cargo run --example full_fundamental_fetch -- AAPL

Prerequisites

• Rust 1.85+ (edition 2024) — This library uses modern Rust features
• TradingView Account — Required for authenticated features (free tier works for most)
• Network Access — Connects to TradingView's servers

Environment Variables

For examples requiring authentication, create a .env file:

TV_USERNAME=your_username
TV_PASSWORD=your_password
TV_TOTP_SECRET=your_2fa_secret  # Optional, for 2FA
TV_AUTH_TOKEN=your_auth_token   # Get from user authentication

Architecture

┌──────────────────────────────────────────────────┐
│                   tradingview-rs                   │
├──────────────────────────────────────────────────┤
│  High-Level API (event-driven)                    │
│  ┌──────────┐    ┌───────────┐    ┌────────────┐ │
│  │  Source   │───▶│ DataLoader │───▶│ EventSink  │ │
│  │ (TV feed) │    │  (fan-out) │    │ (channel,  │ │
│  │           │    │            │    │  callback, │ │
│  │           │    │            │    │  kafka)    │ │
│  └──────────┘    └───────────┘    └────────────┘ │
├──────────────────────────────────────────────────┤
│  Low-Level API (direct access)                    │
│  ┌──────────────┐ ┌──────────────┐ ┌───────────┐ │
│  │  historical  │ │    live      │ │   client   │ │
│  │ (WebSocket)  │ │ (WebSocket)  │ │  (REST)    │ │
│  └──────────────┘ └──────────────┘ └───────────┘ │
├──────────────────────────────────────────────────┤
│  Shared: models, chart, quote, error, utils       │
└──────────────────────────────────────────────────┘

Use Cases

• VNQuant Datafeed — Event-driven data engine with RedPanda (Kafka)
• Algorithmic Trading Bots — Real-time market data for trading strategies
• Market Research — Historical data analysis and backtesting
• Portfolio Management — Track and analyze investment performance
• Technical Analysis — Custom indicators and studies

Documentation

Full API documentation is published on docs.rs. All public types, traits, and modules are documented with examples.

Quick links to key types:

• DataLoader — event-driven orchestrator
• HistoricalClient — historical data
• WebSocketClient — real-time streaming
• Symbol — instrument representation
• Interval — time granularity

For the project roadmap, see ROADMAP.md.

Before Opening an Issue

1. Check existing issues - Your problem might already be reported
2. Update to latest version - Bug fixes are released regularly
3. Review examples - Make sure you're using the API correctly
4. Provide minimal reproduction - Include code that demonstrates the issue
5. Include error messages - Full error output helps with debugging

Known Issues & Limitations

• Rate Limiting — TradingView enforces rate limits; respect them to avoid bans
• Session Expiry — User sessions expire periodically and need renewal
• API Stability — Breaking changes may occur across minor releases prior to 1.0; consult CHANGELOG.md when updating.
• Premium Features — Some features require TradingView Pro/Premium/Expert subscription
• Study Series Loading — Some Pine Script study data series need fixes (see TODO in indicator code)

Roadmap

See ROADMAP.md for planned features, milestones, and version timeline.

Contributing

Contributions are welcome! Please read our Code of Conduct first.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Security

If you discover a security vulnerability, please see our Security Policy for reporting instructions.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Disclaimer

This library is not affiliated with TradingView. Use at your own risk and ensure compliance with TradingView's Terms of Service.