async def test():
bitfinex = ccxt.bitfinex({
'apiKey': "YOUR_API_KEY",
'secret': "YOUR_SECRET",
'verbose': True, # switch it to False if you don't want the HTTP log
})
print(await bitfinex.public_get_symbols())
await bitfinex.close()
async def test():
bitfinex = ccxt.bitfinex({
'apiKey': "4FlEDtxDl35gdEiobnfZ72vJeZteE4Bb7JdvqzjIjHq",
'secret': "D4DXM8DZdHuAq9YptUsb42aWT1XBnGlIJgLi8a7tzFH",
'verbose': True, # switch it to False if you don't want the HTTP log
})
print(await bitfinex.public_get_symbols())
await bitfinex.close()
async def test_bot_checker():
bfx = ccxt.bitfinex({
#
# ↓ The "proxy" property setting below is for CORS-proxying only!
# Do not use it if you don't know what a CORS proxy is.
# https://github.com/ccxt/ccxt/wiki/Install#cors-access-control-allow-origin
# You should only use the "proxy" setting if you're having a problem with Access-Control-Allow-Origin
# In Python you rarely need to use it, if ever at all.
#
# 'proxy': 'https://cors-anywhere.herokuapp.com/',
#
# ↓ The "aiohttp_proxy" setting is for HTTP(S)-proxying (SOCKS, etc...)
# It is a standard method of sending your requests through your proxies
# This gets passed to the `asyncio` and `aiohttp` implementation directly
# You can use this setting as documented here:
# https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support
# This is the setting you should be using with async version of ccxt in Python 3.5+
#
# 'aiohttp_proxy': 'http://proxy.com',
# 'aiohttp_proxy': 'http://*****:*****@some.proxy.com',
# 'aiohttp_proxy': 'http://10.10.1.10:3128',
'enableRateLimit': False,
})
binance = ccxt.binance({
'enableRateLimit': False,
})
try:
# your code goes here...
while True:
ticker1 = await bfx.fetch_ticker('BTC/USD')
ticker2 = await binance.fetch_ticker('BTC/USDT')
if abs(ticker1["last"] - ticker2["last"]) / (
(ticker1["last"] + ticker2["last"]) / 2) > 0.01:
print("Opportunity for arb: {} {} differ: {}%".format(
ticker1["last"], ticker1["last"],
(100 * abs(ticker1["last"] - ticker2["last"])) /
((ticker1["last"] + ticker2["last"]) / 2)))
print("BFX: {} Binance: {}".format(ticker1["last"],
ticker2["last"]))
# await bfx.close()
# await binance.close()
await asyncio.sleep(1)
except:
# traceback.print_stack()
pass
finally:
await bfx.close()
await binance.close()
def is_active_symbol(exchange, symbol):
return ('.' not in symbol) and (('active' not in exchange.markets[symbol])
or (exchange.markets[symbol]['active']))
async def fetch_ticker(exchange, symbol):
ticker = await exchange.fetchTicker(symbol)
print(exchange.id, symbol, ticker)
return ticker
async def fetch_tickers(exchange):
await exchange.load_markets()
print(exchange.id,
'fetching all tickers by simultaneous multiple concurrent requests')
symbols_to_load = get_active_symbols(exchange)
input_coroutines = [
fetch_ticker(exchange, symbol) for symbol in symbols_to_load
]
tickers = await asyncio.gather(*input_coroutines, return_exceptions=True)
for ticker, symbol in zip(tickers, symbols_to_load):
if not isinstance(ticker, dict):
print(exchange.id, symbol, 'error')
else:
print(exchange.id, symbol, 'ok')
print(exchange.id, 'fetched', len(list(tickers)), 'tickers')
asyncio.run(fetch_tickers(ccxt.bitfinex()))
import os
import sys
root = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(root + '/python')
import ccxt.async_support as ccxt # noqa: E402
async def test(exchange):
print(await exchange.fetch_balance())
kraken = ccxt.kraken({
'apiKey': "hEvQNMDIeoCJbr7W/ZBb5CGOrx3G0lWF5B3zqa1JBxdZlEaL8EK+D0Mw",
'secret':
"JaE9wI6Nwgh5oRxiHcVxurwzwBxwc05W/qv/k1srGg4s3EYuXPpNkLLM5NYbbWpM8rCyijIeDavRuqWbU0ZV9A==",
'verbose': True, # switch it to False if you don't want the HTTP log
})
bitfinex = ccxt.bitfinex({
'apiKey': "4FlEDtxDl35gdEiobnfZ72vJeZteE4Bb7JdvqzjIjHq",
'secret': "D4DXM8DZdHuAq9YptUsb42aWT1XBnGlIJgLi8a7tzFH",
'verbose': True, # switch it to False if you don't want the HTTP log
})
[asyncio.ensure_future(test(exchange)) for exchange in [kraken, bitfinex]]
pending = asyncio.Task.all_tasks()
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(*pending))
# -*- coding: utf-8 -*-
import asyncio
import os
import sys
root = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(root + '/python')
import ccxt.async_support as ccxt # noqa: E402
async def main(exchange):
for i in range(0, 10):
# this can be any call instead of fetch_ticker, really
print(await exchange.fetch_ticker('BTC/USD'))
# you can set enableRateLimit = True to enable the built-in rate limiter
# this way you request rate will never hit the limit of an exchange
# the library will throttle your requests to avoid that
exchange = ccxt.bitfinex({
'enableRateLimit': True, # this option enables the built-in rate limiter
})
asyncio.get_event_loop().run_until_complete(main(exchange))
def __init__(self, loop, config):
self.ob_constant = OD_TICK_TIMER
self.bl_constant = BALANCE_TICK_TIMER
self.trade_constant = TRADE_TICK_TIMER
self.stop_tick_time = datetime.datetime.now() + datetime.timedelta(
seconds=TICK_TIMER)
self.orderbook_tick_time = datetime.datetime.now(
) + datetime.timedelta(seconds=self.ob_constant)
self.balance_tick_time = datetime.datetime.now() + datetime.timedelta(
seconds=self.bl_constant)
self.trade_tick_time = datetime.datetime.now() + datetime.timedelta(
seconds=self.trade_constant)
self.info_tick_time = datetime.datetime.now() + datetime.timedelta(
seconds=INFO_TIMER)
self.config = config
self.orderbook_count = 0
self.pair_info = dict()
self.logger = None
if 'logger' in self.config.keys():
self.logger = self.config['logger']
self.exhange = config['exchange']
self.is_auth = False
self.name = '[ccxt %s]' % self.exhange
self.pair_list = set()
if self.exhange == 'liqui':
self.ob_constant = 30
self.bl_constant = 60
self.ccxt_it_queue = self.config['ccxt_in_queue']
self.ccxt_out_queue = self.config['ccxt_out_queue']
self.pair_list = self.config['pairs']
# for i in self.config['pairs']:
# i['balance_tick'] = True
# self.pair_list.add( i['name'] )
auth = {}
if 'auth' in self.config.keys():
auth = self.config['auth']
self.is_auth = True
self.name = '[ccxt %s %s*]' % (self.exhange, auth['apiKey'][:4])
asyncio.set_event_loop(loop)
if self.exhange == 'hitbtc':
loop.create_task(self.run_loop(ccxt.hitbtc(auth)))
elif self.exhange == 'coinmarketcap':
loop.create_task(self.run_loop(ccxt.coinmarketcap()))
elif self.exhange == 'binance':
loop.create_task(self.run_loop(ccxt.binance(auth)))
elif self.exhange == 'bitmex':
loop.create_task(self.run_loop(ccxt.bitmex(auth)))
elif self.exhange == 'huobipro':
loop.create_task(self.run_loop(ccxt.huobipro()))
elif self.exhange == 'liqui':
loop.create_task(self.run_loop(ccxt.liqui(auth)))
elif self.exhange == 'bitfinex2':
loop.create_task(self.run_loop(ccxt.bitfinex2(auth)))
elif self.exhange == 'bitfinex':
loop.create_task(self.run_loop(ccxt.bitfinex(auth)))
elif self.exhange == 'okex':
loop.create_task(self.run_loop(ccxt.okex(auth)))
elif self.exhange == 'kucoin':
loop.create_task(self.run_loop(ccxt.kucoin(auth)))
elif self.exhange == 'bittrex':
loop.create_task(self.run_loop(ccxt.bittrex(auth)))
elif self.exhange == 'qryptos':
loop.create_task(self.run_loop(ccxt.qryptos(auth)))
elif self.exhange == 'kraken':
loop.create_task(self.run_loop(ccxt.kraken(auth)))
loop.run_forever()
import asyncio
import os
import sys
root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(root + '/python')
import ccxt.async_support as ccxt # noqa: E402
async def test(exchange):
print(await exchange.fetch_balance())
await exchange.close()
kraken = ccxt.kraken({
'apiKey': "YOUR_API_KEY",
'secret': "YOUR_SECRET",
'verbose': True, # switch it to False if you don't want the HTTP log
})
bitfinex = ccxt.bitfinex({
'apiKey': "YOUR_API_KEY",
'secret': "YOUR_SECRET",
'verbose': True, # switch it to False if you don't want the HTTP log
})
[asyncio.ensure_future(test(exchange)) for exchange in [kraken, bitfinex]]
pending = asyncio.Task.all_tasks()
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(*pending))
