pip install tradingview-screener

About

This package allows you to create stock screeners with TradingView, and retrieve the data directly from the official API (without doing any kind of web-scraping/HTML-parsing).

Some of its main features are:

• Get data from over 3000 fields, including OHLC, indicators, and fundamental data.
• Variety of markets, including equities, crypto, forex, futures, and bonds.
• Choose the timeframe for each field, such as 1 minute, 5 minutes, 1 hour, or 1 day.
• Filter and sort the results using SQL, a common database language.
• Create and save screeners to easily monitor the markets and identify trading opportunities.

You can find the docs here, and the source on GitHub.

Quickstart

Builtin stock scanners

from tradingview_screener import Scanner

Some of the pre-built scanners:

>>> Scanner.names()

['premarket_gainers',
 'premarket_losers',
 'premarket_most_active',
 'premarket_gappers',
 'postmarket_gainers',
 'postmarket_losers',
 'postmarket_most_active']

Say we want to get the Pre-Market Gainers:

n_rows, df = Scanner.premarket_gainers.get_scanner_data()

And we get a DataFrame with the data:

>>> df

         ticker  name  ...  premarket_change_abs  premarket_volume
0   NASDAQ:APLM  APLM  ...               0.72200          30551043
1      OTC:RNVA  RNVA  ...               0.00005            200000
2      OTC:OCLN  OCLN  ...               0.00690            220000
3   NASDAQ:BKYI  BKYI  ...               0.09740           8826676
4    NASDAQ:ICU   ICU  ...               0.28790           7527703
..          ...   ...  ...                   ...               ...
45     OTC:BSEM  BSEM  ...               0.25000               200
46     NYSE:SWI   SWI  ...               0.76000              5425
47     NYSE:BPT   BPT  ...               0.45000               380
48    NYSE:HOUS  HOUS  ...               0.39000               200
49   NASDAQ:HCM   HCM  ...               1.40000              1950

[50 rows x 8 columns]

With the following columns:

>>> df.columns

Index(['ticker', 'name', 'close', 'volume', 'market_cap_basic',
       'premarket_change', 'premarket_change_abs', 'premarket_volume'],
      dtype='object')

If you aren't yet familiar with Pandas DataFrames, you can convert the output to a list of dictionaries like so:

>>> df.to_dict('records')[:10]

[
    {'ticker': 'NASDAQ:APLM', 'name': 'APLM', 'close': 0.862, 'volume': 94235502, 'market_cap_basic': 146422699.0, 'premarket_change': 127.11267606, 'premarket_change_abs': 0.722, 'premarket_volume': 30551043}
    {'ticker': 'OTC:RNVA', 'name': 'RNVA', 'close': 0.0001, 'volume': 11050007, 'market_cap_basic': 2993432.0, 'premarket_change': 100.0, 'premarket_change_abs': 5e-05, 'premarket_volume': 200000}
    {'ticker': 'OTC:OCLN', 'name': 'OCLN', 'close': 0.0076, 'volume': 2543494, 'market_cap_basic': 9864586.0, 'premarket_change': 86.25, 'premarket_change_abs': 0.0069, 'premarket_volume': 220000}
    {'ticker': 'NASDAQ:BKYI', 'name': 'BKYI', 'close': 0.22, 'volume': 39926873, 'market_cap_basic': 2036156.0, 'premarket_change': 57.05916813, 'premarket_change_abs': 0.0974, 'premarket_volume': 8826676}
    {'ticker': 'NASDAQ:ICU', 'name': 'ICU', 'close': 1.02, 'volume': 46835892, 'market_cap_basic': 19834890.0, 'premarket_change': 36.3510101, 'premarket_change_abs': 0.2879, 'premarket_volume': 7527703}
    ...
]

Creating custom stock screeners

from tradingview_screener import Query, Column

Create a query (like you would in a SQL database):

(Query()
 .select('name', 'close', 'volume', 'relative_volume_10d_calc', 'market_cap_basic')
 .get_scanner_data())

(18060,
          ticker  name  ...  relative_volume_10d_calc  market_cap_basic
 0      AMEX:SPY   SPY  ...                  1.112917               NaN
 1    NASDAQ:QQQ   QQQ  ...                  1.050254               NaN
 2   NASDAQ:TSLA  TSLA  ...                  0.784272      6.589904e+11
 3   NASDAQ:NVDA  NVDA  ...                  0.819148      1.000350e+12
 4   NASDAQ:AMZN  AMZN  ...                  2.206912      1.310658e+12
 ..          ...   ...  ...                       ...               ...
 45     NYSE:UNH   UNH  ...                  0.898852      4.859952e+11
 46  NASDAQ:DXCM  DXCM  ...                  2.763555      3.449933e+10
 47      NYSE:MA    MA  ...                  1.254684      3.429080e+11
 48    NYSE:ABBV  ABBV  ...                  2.007460      2.452179e+11
 49     AMEX:XLK   XLK  ...                  1.041988               NaN
 [50 rows x 6 columns])

Our dataframe only contains 50 rows, even though there are 5271 rows in total. This is because the default LIMIT is 50, but you can change that if you need to. Just keep in mind that the more rows you request, the heavier the load you're putting on the server, and the longer it will take to respond. And if you request too many rows, you might even get banned, so don't get crazy.

A more elaborate query:

(Query()
 .select('name', 'close', 'volume', 'relative_volume_10d_calc')
 .where(
     Column('market_cap_basic').between(1_000_000, 50_000_000),
     Column('relative_volume_10d_calc') > 1.2,
     Column('MACD.macd') >= Column('MACD.signal')
 )
 .order_by('volume', ascending=False)
 .offset(5)
 .limit(25)
 .get_scanner_data())

(393,
          ticker  name     close    volume  relative_volume_10d_calc
 0      OTC:YCRM  YCRM  0.012000  19626514                  1.887942
 1      OTC:PLPL  PLPL  0.000200  17959914                  3.026059
 2   NASDAQ:ABVC  ABVC  1.380000  16295824                  1.967505
 3      OTC:TLSS  TLSS  0.000900  15671157                  1.877976
 4      OTC:GVSI  GVSI  0.012800  14609774                  2.640792
 ..          ...   ...       ...       ...                       ...
 15    AMEX:TPET  TPET  0.483999   2707793                  3.141248
 16     OTC:PWDY  PWDY  0.000700   2138674                  1.802687
 17  NASDAQ:FGEN  FGEN  0.476100   1846644                  1.385978
 18  NASDAQ:VVPR  VVPR  1.930000   1541197                 64.668412
 19     OTC:NAVB  NAVB  0.052000   1475558                  2.491307
 [20 rows x 5 columns])

For more examples have a look here.

How it works

When you call a method like select() or where() on the Query object, it updates a dictionary that contains all the data to send to the API.

For example, the previous query creates the following dictionary:

{
    'markets': ['america'],
    'symbols': {'query': {'types': []}, 'tickers': []},
    'options': {'lang': 'en'},
    'columns': ['name', 'close', 'volume', 'relative_volume_10d_calc'],
    'sort': {'sortBy': 'volume', 'sortOrder': 'desc'},
    'range': [5, 25],
    'filter': [
        {'left': 'market_cap_basic', 'operation': 'in_range', 'right': [1000000, 50000000]},
        {'left': 'relative_volume_10d_calc', 'operation': 'greater', 'right': 1.2},
        {'left': 'MACD.macd', 'operation': 'egreater', 'right': 'MACD.signal'},
    ],
}

When the get_scanner_data() method is called, it will dump that dictionary as a JSON and send it to the API.

Using this package, you can access and query TradingView data with a simple SQL syntax, without needing to know the details of TradingView's API.