tradingview_screener.screeners 

  1from __future__ import annotations
  2
  3from tradingview_screener.query import Query, DEFAULT_RANGE, URL
  4
  5
  6def stocks(market: str = 'america') -> Query:
  7    """
  8    Screener for stocks (common, preferred, DRs, and non-ETF funds), filtered to primary listings
  9    only and sorted by market cap descending.
 10
 11    :param market: Market/country to scan, e.g. ``'america'``, ``'italy'``, ``'germany'``.
 12        Defaults to ``'america'``.
 13    """
 14    return Query(market)
 15
 16
 17def coin() -> Query:
 18    """
 19    Screener for crypto coins (CoinMarketCap universe), sorted by overall rank ascending.
 20    """
 21    q = Query()
 22    q.url = URL.format(market='coin')
 23    q.query = {
 24        'markets': ['coin'],
 25        'symbols': {},
 26        'options': {'lang': 'en'},
 27        'columns': [
 28            'ticker-view',
 29            'crypto_total_rank',
 30            'close',
 31            'type',
 32            'typespecs',
 33            'pricescale',
 34            'minmov',
 35            'fractional',
 36            'minmove2',
 37            'currency',
 38            '24h_close_change|5',
 39            'market_cap_calc',
 40            'fundamental_currency_code',
 41            '24h_vol_cmc',
 42            'circulating_supply',
 43            '24h_vol_to_market_cap',
 44            'socialdominance',
 45            'crypto_common_categories.tr',
 46            'TechRating_1D',
 47            'TechRating_1D.tr',
 48        ],
 49        'sort': {'sortBy': 'crypto_total_rank', 'sortOrder': 'asc'},
 50        'range': DEFAULT_RANGE.copy(),
 51        'ignore_unknown_fields': False,
 52    }
 53    return q
 54
 55
 56def crypto() -> Query:
 57    """
 58    Screener for centralised-exchange (CEX) crypto pairs, sorted by 24 h volume descending.
 59    """
 60    q = Query()
 61    q.url = URL.format(market='crypto')
 62    q.query = {
 63        'markets': ['crypto'],
 64        'symbols': {},
 65        'options': {'lang': 'en'},
 66        'columns': [
 67            'ticker-view',
 68            'exchange.tr',
 69            'provider-id',
 70            'close',
 71            'type',
 72            'typespecs',
 73            'pricescale',
 74            'minmov',
 75            'fractional',
 76            'minmove2',
 77            'currency',
 78            '24h_close_change|5',
 79            '24h_vol|5',
 80            '24h_vol_change|5',
 81            'TechRating_1D',
 82            'TechRating_1D.tr',
 83        ],
 84        'filter2': {
 85            'operator': 'and',
 86            'operands': [
 87                {'expression': {'left': 'centralization', 'operation': 'equal', 'right': 'cex'}}
 88            ],
 89        },
 90        'sort': {'sortBy': '24h_vol|5', 'sortOrder': 'desc'},
 91        'range': DEFAULT_RANGE.copy(),
 92        'ignore_unknown_fields': False,
 93    }
 94    return q
 95
 96
 97def crypto_dex() -> Query:
 98    """
 99    Screener for decentralised-exchange (DEX) spot pairs priced in USD, sorted by 24 h transaction
100    count descending.
101    """
102    q = Query()
103    q.url = URL.format(market='crypto')
104    q.query = {
105        'markets': ['crypto'],
106        'symbols': {},
107        'options': {'lang': 'en'},
108        'columns': [
109            'ticker-view',
110            'blockchain-id.tr',
111            'blockchain-id',
112            'exchange.tr',
113            'provider-id',
114            'close',
115            'type',
116            'typespecs',
117            'pricescale',
118            'minmov',
119            'fractional',
120            'minmove2',
121            'currency',
122            '24h_close_change|5',
123            'dex_txs_count_24h',
124            'dex_trading_volume_24h',
125            'dex_txs_count_uniq_24h',
126            'dex_total_liquidity',
127            'fully_diluted_value',
128            'TechRating_1D',
129            'TechRating_1D.tr',
130        ],
131        'filter2': {
132            'operator': 'and',
133            'operands': [
134                {
135                    'operation': {
136                        'operator': 'and',
137                        'operands': [
138                            {
139                                'expression': {
140                                    'left': 'centralization',
141                                    'operation': 'equal',
142                                    'right': 'dex',
143                                }
144                            },
145                            {
146                                'expression': {
147                                    'left': 'currency_id',
148                                    'operation': 'equal',
149                                    'right': 'USD',
150                                }
151                            },
152                        ],
153                    }
154                },
155                {
156                    'operation': {
157                        'operator': 'or',
158                        'operands': [
159                            {
160                                'operation': {
161                                    'operator': 'and',
162                                    'operands': [
163                                        {
164                                            'expression': {
165                                                'left': 'type',
166                                                'operation': 'equal',
167                                                'right': 'spot',
168                                            }
169                                        }
170                                    ],
171                                }
172                            }
173                        ],
174                    }
175                },
176            ],
177        },
178        'sort': {'sortBy': 'dex_txs_count_24h', 'sortOrder': 'desc'},
179        'range': DEFAULT_RANGE.copy(),
180        'ignore_unknown_fields': False,
181    }
182    return q
183
184
185def forex() -> Query:
186    """
187    Screener for forex currency pairs, sorted by traded value descending.
188    """
189    q = Query()
190    q.url = URL.format(market='forex')
191    q.query = {
192        'markets': ['forex'],
193        'symbols': {},
194        'options': {'lang': 'en'},
195        'columns': ['name', 'close', 'volume', 'currency'],
196        'sort': {'sortBy': 'Value.Traded', 'sortOrder': 'desc'},
197        'range': DEFAULT_RANGE.copy(),
198        'ignore_unknown_fields': False,
199    }
200    return q
201
202
203def futures() -> Query:
204    """
205    Screener for futures contracts, sorted by traded value descending.
206    """
207    q = Query()
208    q.url = URL.format(market='futures')
209    q.query = {
210        'markets': ['futures'],
211        'symbols': {},
212        'options': {'lang': 'en'},
213        'columns': ['name', 'close', 'volume', 'currency'],
214        'sort': {'sortBy': 'Value.Traded', 'sortOrder': 'desc'},
215        'range': DEFAULT_RANGE.copy(),
216        'ignore_unknown_fields': False,
217    }
218    return q
219
220
221def bond() -> Query:
222    """
223    Screener for bonds, sorted by S&P long-term rating descending.
224    """
225    q = Query()
226    q.url = URL.format(market='bond')
227    q.query = {
228        'markets': ['bond'],
229        'symbols': {},
230        'options': {'lang': 'en'},
231        'columns': [
232            'ticker-view',
233            'exchange.tr',
234            'source-logoid',
235            'isin-displayed',
236            'yield_to_worst',
237            'close_pct',
238            'close_net',
239            'type',
240            'typespecs',
241            'fundamental_currency_code',
242            'current_coupon',
243            'maturity_date',
244            'redemption_type.tr',
245            'bond_issuer_type.tr',
246            'bond_snp_rating_lt.tr',
247            'bond_fitch_rating_lt.tr',
248        ],
249        'sort': {'sortBy': 'bond_snp_rating_lt', 'sortOrder': 'desc'},
250        'range': DEFAULT_RANGE.copy(),
251        'ignore_unknown_fields': False,
252    }
253    return q
254
255
256def cfd() -> Query:
257    """
258    Screener for CFDs (contracts for difference), sorted by traded value descending.
259    """
260    q = Query()
261    q.url = URL.format(market='cfd')
262    q.query = {
263        'markets': ['cfd'],
264        'symbols': {},
265        'options': {'lang': 'en'},
266        'columns': ['name', 'close', 'volume', 'currency'],
267        'sort': {'sortBy': 'Value.Traded', 'sortOrder': 'desc'},
268        'range': DEFAULT_RANGE.copy(),
269        'ignore_unknown_fields': False,
270    }
271    return q
272
273
274def options(underlying: str) -> Query:
275    """
276    :param underlying: The underlying symbol to filter by, e.g. ``'CME_MINI:ESM2026'``.
277    """
278    q = Query()
279    q.url = 'https://scanner.tradingview.com/options/scan2?label-product=options-builder'
280    q.query = {
281        'columns': [
282            'ask',
283            'bid',
284            'currency',
285            'delta',
286            'expiration',
287            'gamma',
288            'iv',
289            'option-type',
290            'pricescale',
291            'rho',
292            'root',
293            'strike',
294            'theoPrice',
295            'theta',
296            'vega',
297            'bid_iv',
298            'ask_iv',
299        ],
300        'filter2': {
301            'operator': 'and',
302            'operands': [{'expression': {'left': 'type', 'operation': 'equal', 'right': 'option'}}],
303        },
304        'ignore_unknown_fields': False,
305        'index_filters': [{'name': 'underlying_symbol', 'values': [underlying]}],
306        'options': {'lang': 'en'},
307        'range': DEFAULT_RANGE.copy(),
308    }
309    return q
def stocks(market: str = 'america') -> tradingview_screener.query.Query: 
 7def stocks(market: str = 'america') -> Query:
 8    """
 9    Screener for stocks (common, preferred, DRs, and non-ETF funds), filtered to primary listings
10    only and sorted by market cap descending.
11
12    :param market: Market/country to scan, e.g. ``'america'``, ``'italy'``, ``'germany'``.
13        Defaults to ``'america'``.
14    """
15    return Query(market)

Screener for stocks (common, preferred, DRs, and non-ETF funds), filtered to primary listings only and sorted by market cap descending.

Parameters
  • market: Market/country to scan, e.g. 'america', 'italy', 'germany'. Defaults to 'america'.
def coin() -> tradingview_screener.query.Query: 
18def coin() -> Query:
19    """
20    Screener for crypto coins (CoinMarketCap universe), sorted by overall rank ascending.
21    """
22    q = Query()
23    q.url = URL.format(market='coin')
24    q.query = {
25        'markets': ['coin'],
26        'symbols': {},
27        'options': {'lang': 'en'},
28        'columns': [
29            'ticker-view',
30            'crypto_total_rank',
31            'close',
32            'type',
33            'typespecs',
34            'pricescale',
35            'minmov',
36            'fractional',
37            'minmove2',
38            'currency',
39            '24h_close_change|5',
40            'market_cap_calc',
41            'fundamental_currency_code',
42            '24h_vol_cmc',
43            'circulating_supply',
44            '24h_vol_to_market_cap',
45            'socialdominance',
46            'crypto_common_categories.tr',
47            'TechRating_1D',
48            'TechRating_1D.tr',
49        ],
50        'sort': {'sortBy': 'crypto_total_rank', 'sortOrder': 'asc'},
51        'range': DEFAULT_RANGE.copy(),
52        'ignore_unknown_fields': False,
53    }
54    return q

Screener for crypto coins (CoinMarketCap universe), sorted by overall rank ascending.

def crypto() -> tradingview_screener.query.Query: 
57def crypto() -> Query:
58    """
59    Screener for centralised-exchange (CEX) crypto pairs, sorted by 24 h volume descending.
60    """
61    q = Query()
62    q.url = URL.format(market='crypto')
63    q.query = {
64        'markets': ['crypto'],
65        'symbols': {},
66        'options': {'lang': 'en'},
67        'columns': [
68            'ticker-view',
69            'exchange.tr',
70            'provider-id',
71            'close',
72            'type',
73            'typespecs',
74            'pricescale',
75            'minmov',
76            'fractional',
77            'minmove2',
78            'currency',
79            '24h_close_change|5',
80            '24h_vol|5',
81            '24h_vol_change|5',
82            'TechRating_1D',
83            'TechRating_1D.tr',
84        ],
85        'filter2': {
86            'operator': 'and',
87            'operands': [
88                {'expression': {'left': 'centralization', 'operation': 'equal', 'right': 'cex'}}
89            ],
90        },
91        'sort': {'sortBy': '24h_vol|5', 'sortOrder': 'desc'},
92        'range': DEFAULT_RANGE.copy(),
93        'ignore_unknown_fields': False,
94    }
95    return q

Screener for centralised-exchange (CEX) crypto pairs, sorted by 24 h volume descending.

def crypto_dex() -> tradingview_screener.query.Query: 
 98def crypto_dex() -> Query:
 99    """
100    Screener for decentralised-exchange (DEX) spot pairs priced in USD, sorted by 24 h transaction
101    count descending.
102    """
103    q = Query()
104    q.url = URL.format(market='crypto')
105    q.query = {
106        'markets': ['crypto'],
107        'symbols': {},
108        'options': {'lang': 'en'},
109        'columns': [
110            'ticker-view',
111            'blockchain-id.tr',
112            'blockchain-id',
113            'exchange.tr',
114            'provider-id',
115            'close',
116            'type',
117            'typespecs',
118            'pricescale',
119            'minmov',
120            'fractional',
121            'minmove2',
122            'currency',
123            '24h_close_change|5',
124            'dex_txs_count_24h',
125            'dex_trading_volume_24h',
126            'dex_txs_count_uniq_24h',
127            'dex_total_liquidity',
128            'fully_diluted_value',
129            'TechRating_1D',
130            'TechRating_1D.tr',
131        ],
132        'filter2': {
133            'operator': 'and',
134            'operands': [
135                {
136                    'operation': {
137                        'operator': 'and',
138                        'operands': [
139                            {
140                                'expression': {
141                                    'left': 'centralization',
142                                    'operation': 'equal',
143                                    'right': 'dex',
144                                }
145                            },
146                            {
147                                'expression': {
148                                    'left': 'currency_id',
149                                    'operation': 'equal',
150                                    'right': 'USD',
151                                }
152                            },
153                        ],
154                    }
155                },
156                {
157                    'operation': {
158                        'operator': 'or',
159                        'operands': [
160                            {
161                                'operation': {
162                                    'operator': 'and',
163                                    'operands': [
164                                        {
165                                            'expression': {
166                                                'left': 'type',
167                                                'operation': 'equal',
168                                                'right': 'spot',
169                                            }
170                                        }
171                                    ],
172                                }
173                            }
174                        ],
175                    }
176                },
177            ],
178        },
179        'sort': {'sortBy': 'dex_txs_count_24h', 'sortOrder': 'desc'},
180        'range': DEFAULT_RANGE.copy(),
181        'ignore_unknown_fields': False,
182    }
183    return q

Screener for decentralised-exchange (DEX) spot pairs priced in USD, sorted by 24 h transaction count descending.

def forex() -> tradingview_screener.query.Query: 
186def forex() -> Query:
187    """
188    Screener for forex currency pairs, sorted by traded value descending.
189    """
190    q = Query()
191    q.url = URL.format(market='forex')
192    q.query = {
193        'markets': ['forex'],
194        'symbols': {},
195        'options': {'lang': 'en'},
196        'columns': ['name', 'close', 'volume', 'currency'],
197        'sort': {'sortBy': 'Value.Traded', 'sortOrder': 'desc'},
198        'range': DEFAULT_RANGE.copy(),
199        'ignore_unknown_fields': False,
200    }
201    return q

Screener for forex currency pairs, sorted by traded value descending.

def futures() -> tradingview_screener.query.Query: 
204def futures() -> Query:
205    """
206    Screener for futures contracts, sorted by traded value descending.
207    """
208    q = Query()
209    q.url = URL.format(market='futures')
210    q.query = {
211        'markets': ['futures'],
212        'symbols': {},
213        'options': {'lang': 'en'},
214        'columns': ['name', 'close', 'volume', 'currency'],
215        'sort': {'sortBy': 'Value.Traded', 'sortOrder': 'desc'},
216        'range': DEFAULT_RANGE.copy(),
217        'ignore_unknown_fields': False,
218    }
219    return q

Screener for futures contracts, sorted by traded value descending.

def bond() -> tradingview_screener.query.Query: 
222def bond() -> Query:
223    """
224    Screener for bonds, sorted by S&P long-term rating descending.
225    """
226    q = Query()
227    q.url = URL.format(market='bond')
228    q.query = {
229        'markets': ['bond'],
230        'symbols': {},
231        'options': {'lang': 'en'},
232        'columns': [
233            'ticker-view',
234            'exchange.tr',
235            'source-logoid',
236            'isin-displayed',
237            'yield_to_worst',
238            'close_pct',
239            'close_net',
240            'type',
241            'typespecs',
242            'fundamental_currency_code',
243            'current_coupon',
244            'maturity_date',
245            'redemption_type.tr',
246            'bond_issuer_type.tr',
247            'bond_snp_rating_lt.tr',
248            'bond_fitch_rating_lt.tr',
249        ],
250        'sort': {'sortBy': 'bond_snp_rating_lt', 'sortOrder': 'desc'},
251        'range': DEFAULT_RANGE.copy(),
252        'ignore_unknown_fields': False,
253    }
254    return q

Screener for bonds, sorted by S&P long-term rating descending.

def cfd() -> tradingview_screener.query.Query: 
257def cfd() -> Query:
258    """
259    Screener for CFDs (contracts for difference), sorted by traded value descending.
260    """
261    q = Query()
262    q.url = URL.format(market='cfd')
263    q.query = {
264        'markets': ['cfd'],
265        'symbols': {},
266        'options': {'lang': 'en'},
267        'columns': ['name', 'close', 'volume', 'currency'],
268        'sort': {'sortBy': 'Value.Traded', 'sortOrder': 'desc'},
269        'range': DEFAULT_RANGE.copy(),
270        'ignore_unknown_fields': False,
271    }
272    return q

Screener for CFDs (contracts for difference), sorted by traded value descending.

def options(underlying: str) -> tradingview_screener.query.Query: 
275def options(underlying: str) -> Query:
276    """
277    :param underlying: The underlying symbol to filter by, e.g. ``'CME_MINI:ESM2026'``.
278    """
279    q = Query()
280    q.url = 'https://scanner.tradingview.com/options/scan2?label-product=options-builder'
281    q.query = {
282        'columns': [
283            'ask',
284            'bid',
285            'currency',
286            'delta',
287            'expiration',
288            'gamma',
289            'iv',
290            'option-type',
291            'pricescale',
292            'rho',
293            'root',
294            'strike',
295            'theoPrice',
296            'theta',
297            'vega',
298            'bid_iv',
299            'ask_iv',
300        ],
301        'filter2': {
302            'operator': 'and',
303            'operands': [{'expression': {'left': 'type', 'operation': 'equal', 'right': 'option'}}],
304        },
305        'ignore_unknown_fields': False,
306        'index_filters': [{'name': 'underlying_symbol', 'values': [underlying]}],
307        'options': {'lang': 'en'},
308        'range': DEFAULT_RANGE.copy(),
309    }
310    return q
Parameters
  • **underlying: The underlying symbol to filter by, e.g. 'CME_MINI**: ESM2026'.