def __init__(self, name): self.name = name self.conf = Settings.makeSettings(Settings.loadTomlSettings(name)) secret = open(self.conf.credentialsFilePath).read() secret = secret.split('\n') self.API = ccxt.binance({ 'apiKey': secret[0], 'secret': secret[1] }) self.API.load_markets()
def set_tickers(self): global session_key if session_key: s = SessionStore(session_key=session_key) s.delete() exchange = ccxt.binance() s = SessionStore() s['tickers'] = exchange.fetch_tickers() s.create() session_key = s.session_key
def __init__(self): self.exchanges = { 'binanceus': ccxt.binanceus(), 'bittrex': ccxt.bittrex(), # 'coinbase': ccxt.coinbase(), # coinbase has most currency pairs, by like 3 times the next highest, consider removing. Also coinbase limits API to 3-6 calls/sec 'gemini': ccxt.gemini(), # 'kraken': ccxt.kraken(), # updating their API 'livecoin': ccxt.livecoin(), 'theocean': ccxt.theocean(), # 'okex': ccxt.okex(), #Canadian, does not allow us 'bitmart': ccxt.bitmart(), # 'cex': ccxt.cex(), # EU # 'bitbay': ccxt.bitbay(), # EU, Updating API # 'bcex': ccxt.bcex(), #candian exch, their API is updating # 'bitbay': ccxt.bitbay(), 'paymium': ccxt.paymium(), 'binance': ccxt.binance(), 'okcoin': ccxt.okcoin(), 'bitfinex': ccxt.bitfinex() # non-US } # creates a markets variable in each exchange instance. ex. exchages[0].markets will return markets self.loadMarkets() # these are tickers available on exchnage, but not US customers, or don't allow deposits/withdrawals self.unavailableTickers = { 'binanceus': [], 'bittrex': [ 'LUNA/BTC', 'ABBC/BTC', 'Capricoin/BTC', 'DRGN/BTC', 'CVT/BTC', 'NXT/BTC' ], # 'coinbase': [], 'gemini': [], # 'kraken': [], # Updating their API 'livecoin': [ 'BTM/BTC', 'BTM/ETH', 'NANO/BTC', 'NANO/ETH', 'XTZ/BTC', 'XTZ/ETH', 'THETA/BTC', 'THETA/ETH', 'ABBC/BTC', 'ABBC/ETH', 'AE/BTC', 'AE/ETH', 'IOST/BTC', 'IOST/ETH' ], 'theocean': [], # 'okex': ['AET/ETH','AET/BTC'], # does not allow US, but allows canadian 'bitmart': [], # 'cex': [], # 'bitbay': [], # 'bcex': [], #candian exch, their API is updating 'bitbay': [], 'paymium': [], 'binance': [], 'okcoin': [], 'bitfinex': [] } self.commonTickers = self.getCommonTickers() # then only call fetch_tickers for common_tickers between exchanges self.minProfit = 1 # percent profit # in USD NOTE: still need to incorporate this. I think coinmarketcap API has a quick conversion call self.minVolume = 200 self.txfrCosts = []
def __init__(self): os.chdir(sys.path[0]) self.symbol = "BUSD/USDT" self.bid = None self.timeout_var = 10 if (os.path.exists("config.json") and os.stat("config.json").st_size): with open("config.json", "r") as f: keys = json.load(f) api_key = keys['apikey'] secret_key = keys['secretkey'] else: api_key = input("Enter API key: ") secret_key = input("Enter secret key: ") with open("config.json", "w") as f: temp = json.dumps({'apikey': api_key, 'secretkey': secret_key}) f.write(temp) self.exchange = ccxt.binance({ 'apiKey': api_key, 'secret': secret_key, 'timeout': 30000, 'enableRateLimit': True, }) print(self.is_open()) bal = self.get_bal() print("USDT", bal[0]) print("BUSD", bal[1]) tot = bal[0] + bal[1] self.initial_tot_bal = self.total_bank() if (os.path.exists("raise_data.json") and os.stat("raise_data.json").st_size): with open('raise_data.json', 'r') as f: try: dat = json.load(f) except json.decoder.JSONDecodeError as e: print(e) print(f.read()) open('raise_data.json', 'w').close() dat = { "last_balance": None, "total_lost": 0, "trading_volume": 0 } with open('raise_data.json', 'w') as f: f.write(json.dumps(dat)) else: with open('raise_data.json', 'w') as f: f.write(json.dumps({'last_balance': tot, 'total_lost': 0})) self.is_open(display=True)
def run(self, ): while 1: public_client = cbpro.PublicClient() binance = ccxt.binance() ticker = binance.fetch_ticker('BTC/USDT') self.lock.acquire() self.binance_price[0] = ticker['close'] self.coinbase_price[0] = public_client.get_product_ticker(product_id='BTC-USD')['price'] self.lock.release() time.sleep(2)
def init_binance(self): binance = ccxt.binance({ 'apiKey': self.apiKey, 'secret': self.secret, 'enableRateLimit': True, 'options': { 'defaultType': 'future', # ←-------------- quotes and 'future' }, }) return binance
def get_ticker(update, context): time.sleep(1) print(type(context.args[0])) ticker = binance().fetch_ticker(symbol=context.args[0]) if ticker['info']: del ticker['info'] text = '' for k,v in ticker.items(): text += k.capitalize() +': '+str(v)+'\n' text += 'ChatId:' + str(update.effective_chat.id) print(text) context.bot.send_message(chat_id=update.effective_chat.id, text=text)
def test_real_api(self): import ccxt client = ccxt.binance() provider = CCXTInstrumentProvider(client=client) # Act provider.load_all() # Assert self.assertTrue(provider.count > 0) # No exceptions raised
def get_coin_data(self, bot_id, exchange, pair, api_key, secret_key): store = self.store store.log.info('Run get_bollinger_info ...') if exchange == "binance": exchange_obj = ccxt.binance({ 'proxies': { 'http': 'http://*****:*****@us-wa.proxymesh.com:31280', 'https': 'http://*****:*****@us-wa.proxymesh.com:31280', }, 'apiKey': api_key, 'secret': secret_key, }) cur_data = exchange_obj.fetch_ticker(pair) bid_price = float(cur_data['info']['bidPrice']) ask_price = float(cur_data['info']['askPrice']) cur_timestamp = cur_data['timestamp'] cur_standard_time = datetime.datetime.fromtimestamp(cur_timestamp/1000) total_balance = exchange_obj.fetch_balance() base_balance = float(total_balance[pair.split("/")[1]]['total']) coin_balance = float(total_balance[pair.split("/")[0]]['total']) buy_exchange_fee = exchange_obj.calculate_fee(pair, 'market', 'buy', 1, ask_price, 'maker') buy_fee = round(ask_price * float(buy_exchange_fee['rate']), 8) # is this right, it is necessary to multiply ask_price sell_exchange_fee = exchange_obj.calculate_fee(pair, 'market', 'sell', 1, bid_price, 'maker') sell_fee = round(bid_price * float(sell_exchange_fee['rate']), 8) ###### Check order status query = "select order_id from trading_history where bot.bot_id=%d and filled=0" % (bot_id,) store.set_query(query) order_id = store.read() if len(order_id) > 0: if exchange == "binance": order_info = exchange_obj.fetch_order(id=order_id[0][0], symbol=pair) order_status = order_info['status'] if order_status == "closed": query = "update trading_history set filled=1 where order_id=%d" % (order_id[0][0], ) store.set_query(query) store.write() elif order_status == "open": store.log.info("There are open order still ...") context = { 'bid_price': bid_price, 'ask_price': ask_price, 'timestamp': cur_timestamp, 'date_time': cur_standard_time, 'coin_balance': coin_balance, 'base_balance': base_balance, 'sell_fee': sell_fee, 'buy_fee': buy_fee, 'order_status': order_status } return context
def Orders_excuted(self,history=1,symbol='BTC/USDT'): self.history=history self.symbol=symbol shift=self.history*60*60*1000 exchange=ccxt.binance() exchange.load_markets() #symbol='BTC/USDT' if exchange.has['fetchTrades']: # for symbol in exchange.markets: # ensure you have called loadMarkets() or load_markets() method. d=pd.DataFrame(exchange.fetch_trades (self.symbol,since=exchange.fetchTime(params = {})-shift)) self.orders=d
def get_binance_history_data(resolution, ticker): binance = ccxt.binance() if binance.has['fetchOHLCV']: candle_close_prices = [ x[4] for x in binance.fetch_ohlcv(ticker, resolution) ] # print(candle_close_prices) print("For %s with step = %s we got %s results" % (ticker, resolution, len(candle_close_prices))) return candle_close_prices
def get_market(market=OKEX): mk = ccxt.okcoinusd() if market == HUOBI: mk = ccxt.huobipro() if market == CRY: mk = ccxt.cryptopia() if market == BIN: mk = ccxt.binance() if market == PLX: mk = ccxt.poloniex() return mk
def sell_crypto(self, ticker, sell_volume): for i in range(10000): try: sell_trade = self.exchange.create_order(ticker,'market','sell',sell_volume) break except Exception as e: print(e, '\n\nTrying to sell position again') self.exchange = ccxt.binance({'apiKey':self.api_keys['api_key'], 'secret':self.api_keys['secret_key']}) print('\n',sell_trade) return sell_trade
def __init__(self, api_keys, logfile=False, block=False, account_json=None): self.api_keys = {'api_key':api_keys['binance_keys']['api_key'],'secret_key':api_keys['binance_keys']['secret_key']} self.exchange = ccxt.binance({'apiKey':self.api_keys['api_key'], 'secret':self.api_keys['secret_key']}) self.logfile = logfile self.block = block self.started_time = datetime.now() self.account_json = account_json # Set of tickers to block if specified if self.block: self.block_set = set()
def init_supported_exchanges(): objects = { "binance": ccxt.binance(), "bitfinex": ccxt.bitfinex(), "bitflyer": ccxt.bitflyer(), "bitstamp": ccxt.bitstamp(), "bittrex": ccxt.bittrex(), "coinbase": ccxt.coinbase(), "kraken": ccxt.kraken(), "poloniex": ccxt.poloniex() } return objects
def __init__(self, trading_pair, timeframe): self.exchange = ccxt.binance() self.trading_pair = trading_pair if timeframe == "5min": self.timeframe = "5m" self.timeframe_min = 5 else: print("timeframe not implemented") self._limit = 1000 self._second = 1000 self._minute = 60 * 1000
def __init__(self, coin_pair, coin, coin2): self.key = get_config()["exchange_key"] self.secret = get_config()["exchange_secret"] self.exchange = ccxt.binance({ "apiKey": self.key, "secret": self.secret, "enableRateLimit": False }) self.coin_pair = coin_pair self.coin = coin self.coin2 = coin2 self.paper_enabled = get_config()["paper_trading"]
def __init__(self): api = pd.read_csv('../api.csv') self.binance = ccxt.binance({'options': {'adjustForTimeDifference': True}, 'apiKey': api['apiKey'][0], 'secret': api['secret'][0]}) balance = self.binance.fetchBalance()['free'] self.coins_units = {coin: units for coin, units in balance.items() if units > 0.01 and coin != 'ENJ'}
def __init__(self, coin_pair, coin1, coin2): self.key = os.getenv("BINANCE_API_KEY") self.secret = os.getenv("BINANCE_API_SECRET") self.exchange = ccxt.binance({ "apiKey": self.key, "secret": self.secret, "enableRateLimit": False }) self.coin_pair = coin_pair self.coin = coin1 self.coin2 = coin2 self.paper_enabled = "yes"
def get_binance_connection(key, secret): try: binance = ccxt.binance({ 'apiKey': key, 'secret': secret }) log("INFO", "Successfully established connection to Binance API") return binance except Exception as e: log("ERROR", f"Failed to establish connection to Binance API: {e}") return
def create_exchanges(): """ instantiate the markets to include more exchanges use this function. new exchanges need to be hand-coded here """ coinbasepro = ccxt.coinbasepro({ 'apiKey': api_keys.coinbasepro['apiKey'], 'secret': api_keys.coinbasepro['secret'], }) poloniex = ccxt.poloniex({ 'apiKey': api_keys.poloniex['apiKey'], 'secret': api_keys.poloniex['secret'], }) bittrex = ccxt.bittrex({ 'apiKey': api_keys.bittrex['apiKey'], 'secret': api_keys.bittrex['secret'], }) binance = ccxt.binance({ 'apiKey': api_keys.binance['apiKey'], 'secret': api_keys.binance['secret'], }) bitfinex = ccxt.bitfinex({ 'apiKey': api_keys.bitfinex['apiKey'], 'secret': api_keys.bitfinex['secret'], }) kraken = ccxt.kraken({ 'apiKey': api_keys.kraken['apiKey'], 'secret': api_keys.kraken['secret'], }) bitmex = ccxt.bitmex({ 'apiKey': api_keys.bitmex['apiKey'], 'secret': api_keys.bitmex['secret'], }) okex = ccxt.okex({ 'apiKey': api_keys.okex['apiKey'], 'secret': api_keys.okex['secret'], }) exchanges = [coinbasepro, poloniex, bittrex, binance, bitfinex, kraken, bitmex, okex] timing_limits = [ .35, .35, 1, .35, 2, 1, 1, .35] # requesting period limit per exchange for exchange, timing in zip(exchanges, timing_limits): g_storage.timer[exchange.name] = [0, timing] return exchanges
def extract_ohlcv_binance(pair='BTC/USDT', interval='1m', display=False): # pair = trading pair (e.g. 'BTC/USDT', 'ETH/USDT', 'BCH/USDT', 'BNB/USDT', 'ADA/USDT') # interval = time interval between data points (e.g. '1m', '1h', '1d', '1w', '1M') # display = display progress # List of ids for all supported exchanges # exchange_list = ccxt.exchanges # Load exchange and markets exchange = ccxt.binance() markets = exchange.load_markets() # Available trading pairs symbols = exchange.symbols if not pair in symbols: print('Error: Pair not supported.') return 0 # OHLCV (open-highest-lowest-closing-volume) history if not exchange.has['fetchOHLCV']: print('Error: Cannot fetch OHLCV data.') return 0 # Time interval tframes = exchange.timeframes if not interval in tframes: print('Error: Interval not supported') return 0 time_interval = tframes[interval] # Time interval between data points # Build dataset data = exchange.fetch_ohlcv(pair, interval, since=0) # Initial data data_array = np.array(data) dataset = np.empty((0,data_array.shape[1])) # Dataset to be built # While there is still data to be extracted # Note: Can only extract ~1000 data points per fetch_ohlcv call. while data: if display: print(str(len(dataset) + len(data)) + ' data points extracted...') # Add extracted data to dataset dataset = np.vstack([dataset,data_array]) # Timestamp of the last entry last_time = int(data_array[-1][0]) # Extract next sequence of data data = exchange.fetch_ohlcv(pair, interval, since=last_time+1) data_array = np.array(data) return dataset
def get_exchange_list(): bittrex_exchange = ccxt.bittrex() binance_exchange = ccxt.binance() kucoin_exchange = ccxt.kucoin() huobiPro_exchange = ccxt.huobipro() cryptopia_exchange = ccxt.cryptopia() bitmex_exchange = ccxt.bitmex() list_of_exchanges = [ bittrex_exchange, binance_exchange, kucoin_exchange, huobiPro_exchange, cryptopia_exchange ] return list_of_exchanges
def __init__(self, binance_access_key, binance_secret_key): self.binance = ccxt.binance({ 'apiKey': binance_access_key, 'secret': binance_secret_key, 'options': { 'adjustForTimeDifference': True }, 'verbose': True }) self.only_btc_tickers, self.only_usdt_tickers, self.both_tickers = self._get_tickers( )
def loadExchanges(): exchanges = [] with open(key_file) as json_file: keys = json.load(json_file) binance = ccxt.binance() binance.apiKey = keys['exchanges']['binance']['key'] binance.secret = keys['exchanges']['binance']['secret'] exchanges.append(binance) return exchanges
def test4(): symbol = 'BCD/BTC' t1 = Exchange.Exchange(ccxt.binance()) t1.add_book(abook, symbol) t2 = Exchange.Exchange(ccxt.bitz()) t2.add_book(cbook, 'BCD/BTC') pair = Pair.Pair(t1, t2, 'BCD/BTC') print(pair.max_trade()) print(pair.min_trade()) print(pair.Margin) print(pair.FlatFees) print(pair.PercentFees)
def crawl_bybit_datas(symbol, start_time, end_time): exchange = ccxt.binance() print(exchange) current_path = os.getcwd() file_dir = os.path.join(current_path, symbol.replace('/', '')) print(file_dir) if not os.path.exists(file_dir): # 如果这个文件路径不存在,则创建这个文件夹,来存放数据. os.makedirs(file_dir) start_time = start_time end_time = end_time start_time = datetime.datetime.strptime(start_time, '%Y-%m-%d') end_time = datetime.datetime.strptime(end_time, '%Y-%m-%d') # 我不知道为什么要*1000 start_time_stamp = int(time.mktime(start_time.timetuple())) * 1000 end_time_stamp = int(time.mktime(end_time.timetuple())) * 1000 limit_count = 200 while True: try: print(start_time_stamp) data = exchange.fetch_ohlcv(symbol, timeframe='1d', since=start_time_stamp, limit=limit_count) df = pd.DataFrame(data) df.rename(columns={ 0: 'open_time', 1: 'open', 2: 'high', 3: 'low', 4: 'close', 5: 'value' }, inplace=True) # start_time_stamp = int(df.iloc[-1]['open_time']) # 获取下个请求的时间 start_time_stamp = int(df.iloc[-1][0]) # 获取下一个次请求的时间. filename = str(start_time_stamp) + '.csv' save_file_path = os.path.join(file_dir, filename) print("文件保存路径为:%s" % save_file_path) df.set_index('open_time', drop=True, inplace=True) df.to_csv(save_file_path) if start_time_stamp > end_time_stamp: print("完成请求") break time.sleep(0.2) except Exception as error: print(error) time.sleep(10)
def market_depth(sym, exchange=ccxt.binance(), num_entries=20): #Get market depth #Retrieve and format market depth (order book) including time-stamp i = 0 #Used as a counter for number of entries print( "Order Book: " ) #convert_time_binance(client.get_server_time())) #Transfer to CCXT exchange.verbose = True depth = exchange.fetch_order_book(symbol=sym) #Transf'd to CCXT #pprint(depth) print(depth['asks'][0]) ask_tot = 0.0 ask_price = [] ask_quantity = [] bid_price = [] bid_quantity = [] bid_tot = 0.0 place_order_ask_price = 0 place_order_bid_price = 0 max_order_ask = 0 max_order_bid = 0 print("\n", sym, "\nDepth ASKS:\n") #Edit to work with CCXT print("Price Amount") for ask in depth['asks']: if i < num_entries: if float(ask[1]) > float(max_order_ask): #Determine Price to place ask order based on highest volume max_order_ask = ask[1] #print("Max Order ASK: ", max_order_ask) place_order_ask_price = round(float(ask[0]), 5) - 0.0001 #ask_list.append([ask[0], ask[1]]) ask_price.append(float(ask[0])) ask_tot += float(ask[1]) ask_quantity.append(ask_tot) #print(ask) i += 1 j = 0 #Secondary Counter for Bids print("\n", sym, "\nDepth BIDS:\n") print("Price Amount") for bid in depth['bids']: if j < num_entries: if float(bid[1]) > float(max_order_bid): #Determine Price to place ask order based on highest volume max_order_bid = bid[1] #print("Max Order BID: ", max_order_bid) place_order_bid_price = round(float(bid[0]), 5) + 0.0001 bid_price.append(float(bid[0])) bid_tot += float(bid[1]) bid_quantity.append(bid_tot) #print(bid) j += 1 return ask_price, ask_quantity, bid_price, bid_quantity, place_order_ask_price, place_order_bid_price
def kimp(): c = CurrencyConverter('http://www.ecb.europa.eu/stats/eurofxref/eurofxref.zip') exchange_rate = round(c.convert(1, 'USD', 'KRW'),2) #환율 #print(exchange_rate) binance = ccxt.binance() markets_binance = binance.fetch_tickers() #print(markets_binance.keys()) binance_BTC = binance.fetch_ticker('BTC/USDT') binance_BTC_close = binance_BTC['close'] #print(binance_BTC_close) upbit = ccxt.upbit() markets_upbit = upbit.fetch_tickers() #print(markets_upbit.keys()) upbit_BTC = upbit.fetch_ticker('BTC/KRW') upbit_BTC_close = upbit_BTC['close'] #print(upbit_BTC_close) kimp_BTC = round(((upbit_BTC_close/(binance_BTC_close*exchange_rate) - 1) * 100),2) binance_ETH = binance.fetch_ticker('ETH/USDT') binance_XRP = binance.fetch_ticker('XRP/USDT') binance_ADA = binance.fetch_ticker('ADA/USDT') binance_ETH_close = binance_ETH['close'] binance_XRP_close = binance_XRP['close'] binance_ADA_close = binance_ADA['close'] upbit_ETH = upbit.fetch_ticker('ETH/KRW') upbit_XRP = upbit.fetch_ticker('XRP/KRW') upbit_ADA = upbit.fetch_ticker('ADA/KRW') upbit_ETH_close = upbit_ETH['close'] upbit_XRP_close = upbit_XRP['close'] upbit_ADA_close = upbit_ADA['close'] kimp_ETH = round(((upbit_ETH_close / (binance_ETH_close * exchange_rate) - 1) * 100)) kimp_XRP = round(((upbit_XRP_close / (binance_XRP_close * exchange_rate) - 1) * 100)) kimp_ADA = round(((upbit_ADA_close / (binance_ADA_close * exchange_rate) - 1) * 100)) format_upbit_BTC_close = format(upbit_BTC_close, ",")[:-2] format_upbit_ETH_close = format(upbit_ETH_close, ",")[:-2] format_upbit_XRP_close = format(upbit_XRP_close, ",")[:-2] format_upbit_ADA_close = format(upbit_ADA_close, ",")[:-2] # now = datetime.datetime.now().time() now = time.strftime('%y-%m-%d %H:%M:%S') s = f"현재시간 : {now} <br><br>\n" \ f"BTC : {format_upbit_BTC_close} ({kimp_BTC}%) <p> \n" \ f"ETH : {format_upbit_ETH_close} ({kimp_ETH}%) <p> \n" \ f"XRP : {format_upbit_XRP_close} ({kimp_XRP}%) <p> \n" \ f"ADA : {format_upbit_ADA_close} ({kimp_ADA}%)" return s
def request_instruments(): client = ccxt.binance({ "apiKey": "", "secret": "", "timeout": 10000, # Hard coded for now "enableRateLimit": True, # Hard coded for now }) client.load_markets() res = client.markets with open('res_instruments.json', 'w') as json_file: json.dump(res, json_file)
def __init__(self, config, debug=True): key_config = config['apikey'] self.debug = debug self.exchanges = { 'zb': Zb(key_config['zb']['key'], key_config['zb']['secret']), 'okex': Okex(key_config['okex']['key'], key_config['okex']['secret']), 'weex': Weex(key_config['weex']['key'], key_config['weex']['secret']), # 'huobipro': Huobipro(key_config['huobipro']['key'], key_config['huobipro']['secret']), 'bithumb': ccxt.bithumb(), 'binance': ccxt.binance(), 'bitflyer': ccxt.bitflyer(), 'hitbtc': ccxt.hitbtc(), 'coincheck': ccxt.coincheck(), "quoinex": ccxt.quoinex(), "bitfinex": ccxt.bitfinex(), "hitbtc": ccxt.hitbtc(), } self.engine = MysqlEngine(config['db']['url']) self.pool = ThreadPoolExecutor(3) # for many urls, this should probably be capped at some value. self.async = False
# -*- coding: utf-8 -*- 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 # noqa: E402 exchange = ccxt.binance({ 'apiKey': 'YOUR_API_KEY', 'secret': 'YOUR_SECRET', 'enableRateLimit': True, }) symbol = 'ETH/BTC' type = 'limit' # or 'market' side = 'sell' # or 'buy' amount = 1.0 price = 0.060154 # or None # extra params and overrides if needed params = { 'test': True, # test if it's valid, but don't actually place it } order = exchange.create_order(symbol, type, side, amount, price, params) print(order)
def get_binance_data(symbol, timeframe, length, include_current_candle = True, file_format = ['txt', 'csv'], api_cooldown_seconds = 0): """ Download Crypto OHLCV Data from Binance. The function fetches OHLCV data via the specified paramteres from the public Binance API, merges it into a Pandas Data Frame and optionally saves the Data Frame as .txt and/or .csv file. Through concatenation more data than specified by the maximal request length of the exchange can be fetched. Additional timeframes are available (merged from smaller timeframes). Parameters ---------- symbol : str Symbol of the underlying data, e.g. 'BTC/USDT' timeframe : str Timeframe of the underlying data, e.g. '1h' length : int Number of Timeframes (Data length), e.g. 500 include_current_candle : bool Include the current, not finished, candle, e.g. True file_format : str, list Which file format should be used to save the data, e.g. 'csv' or ['txt', 'csv'] api_cooldown_seconds : int, float When fetching a lot of data this allows each request to the API to be made after the amount in seconds has passed. This prevents possible API errors due to too many requests within a short time. Returns ------- Pandas Data Frame and optionally .txt and/or .csv file. A table with headers 'Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume' containing the requested data. Dependencies ------------ import ccxt import time import csv import pandas as pd """ data_limit = 500 # int(ccxt.binance({}).describe()['ratelimit']) returns 500 binance_symbols = [market['symbol'] for market in ccxt.binance({}).fetch_markets()] binance_timeframes = {'1m': 60*1000, '3m': 3*60*1000, '5m': 5*60*1000, '15m': 15*60*1000, '30m': 30*60*1000, '1h': 60*60*1000, '2h': 2*60*60*1000, '4h': 4*60*60*1000, '6h': 6*60*60*1000, '12h': 12*60*60*1000, '1d': 24*60*60*1000, '3d': 3*24*60*60*1000, '1w': 7*24*60*60*1000} missing_timeframes = {'3h': ['1h', 3, 60*60*1000], '2w': ['1w', 2, 7*24*60*60*1000]} timestamp = [] openx = [] high = [] low = [] close = [] volume = [] timestamp_temp = [] openx_temp = [] high_temp = [] low_temp = [] close_temp = [] volume_temp = [] proceed = True if symbol not in binance_symbols: print("ERROR:\tPlease use one of the following Symbols:\n\t" + "\n\t".join(sorted(binance_symbols))) proceed = False if not(timeframe in binance_timeframes.keys() or timeframe in missing_timeframes.keys()): print("ERROR:\tPlease use one of the following Timeframes:\n\tMinute:\t'1m', '3m', '5m', '15m', '30m',\n\tHour:\t'1h', '2h', '3h', '4h', '6h', '12h',\n\tDay:\t'1d', '3d',\n\tWeek:\t'1w', '2w'") proceed = False if not isinstance(length, int) or length < 1: print("ERROR:\tPlease use a reasonable number for the argument 'length'.") proceed = False if type(include_current_candle) != bool: print("ERROR:\tPlease use boolean values for argument 'include_current_candle' only.") proceed = False if not(file_format == 'txt' or file_format == 'csv' or file_format == ['txt'] or file_format == ['csv'] or file_format == ['csv', 'txt'] or file_format == ['txt', 'csv'] or file_format == '' or file_format == [] or file_format == [''] or file_format == None): print("ERROR:\tAllowed values for argument 'file_format' are 'csv', 'txt', ['csv', 'txt'].\n\tIf you do not wish to save the data please use either '', [''], [], None.") proceed = False if file_format == '' or file_format == [] or file_format == [''] or file_format == None: file_format = [] if file_format == 'csv': file_format = ['csv'] if file_format == 'txt': file_format = ['txt'] if not isinstance(api_cooldown_seconds, (int, float)) or api_cooldown_seconds < 0 or api_cooldown_seconds > 60: print("ERROR:\tPlease use a reasonable 'api_cooldown_seconds' number of seconds (between 0 and 60).") proceed = False if proceed == True: if timeframe in missing_timeframes.keys(): if include_current_candle == True: n_bulk = (length * missing_timeframes[timeframe][1]) // data_limit remainder = (length * missing_timeframes[timeframe][1]) % data_limit if include_current_candle == False: n_bulk = ((length + 1) * missing_timeframes[timeframe][1]) // data_limit remainder = ((length + 1) * missing_timeframes[timeframe][1]) % data_limit while n_bulk > 0: since = round(ccxt.binance({}).milliseconds() - (ccxt.binance({}).milliseconds() % (missing_timeframes[timeframe][1] * missing_timeframes[timeframe][2])) - (n_bulk * data_limit * missing_timeframes[timeframe][2]) - (remainder * missing_timeframes[timeframe][2])) for block in ccxt.binance({}).fetch_ohlcv(symbol = symbol, timeframe = missing_timeframes[timeframe][0], since = (since + (missing_timeframes[timeframe][1] * missing_timeframes[timeframe][2])), limit = data_limit): timestamp_temp.append(block[0]) openx_temp.append(block[1]) high_temp.append(block[2]) low_temp.append(block[3]) close_temp.append(block[4]) volume_temp.append(block[5]) n_bulk -= 1 if n_bulk > 0 or remainder > 0: time.sleep(api_cooldown_seconds) if remainder > 0: since = round(ccxt.binance({}).milliseconds() - (ccxt.binance({}).milliseconds() % (missing_timeframes[timeframe][1] * missing_timeframes[timeframe][2])) - (remainder * missing_timeframes[timeframe][2])) for block in ccxt.binance({}).fetch_ohlcv(symbol = symbol, timeframe = missing_timeframes[timeframe][0], since = (since + (missing_timeframes[timeframe][1] * missing_timeframes[timeframe][2])), limit = remainder + 1): timestamp_temp.append(block[0]) openx_temp.append(block[1]) high_temp.append(block[2]) low_temp.append(block[3]) close_temp.append(block[4]) volume_temp.append(block[5]) if length > 1: for i in [num for num in range(0, len(timestamp_temp), missing_timeframes[timeframe][1])][:-1]: timestamp.append(timestamp_temp[i]) openx.append(openx_temp[i]) high.append(max(high_temp[i:i + missing_timeframes[timeframe][1]])) low.append(min(low_temp[i:i + missing_timeframes[timeframe][1]])) close.append(close_temp[i + (missing_timeframes[timeframe][1] - 1)]) volume.append(sum(volume_temp[i:i + missing_timeframes[timeframe][1]])) # append all available remaining smaller timeframes to the lists timestamp.append(timestamp_temp[i + missing_timeframes[timeframe][1]]) openx.append(openx_temp[i + missing_timeframes[timeframe][1]]) high.append(max(high_temp[i + missing_timeframes[timeframe][1]:])) low.append(min(low_temp[i + missing_timeframes[timeframe][1]:])) close.append(close_temp[-1]) volume.append(sum(volume_temp[i + missing_timeframes[timeframe][1]:])) if length == 1: timestamp.append(timestamp_temp[0]) openx.append(openx_temp[0]) high.append(max(high_temp[0:])) low.append(min(low_temp[0:])) close.append(close_temp[-1]) volume.append(sum(volume_temp[0:])) if timeframe not in missing_timeframes.keys(): if include_current_candle == True: n_bulk = length // data_limit remainder = length % data_limit if include_current_candle == False: n_bulk = (length + 1) // data_limit remainder = (length + 1) % data_limit while n_bulk > 0: since = ccxt.binance({}).milliseconds() - (n_bulk * data_limit * binance_timeframes[timeframe]) - (remainder * binance_timeframes[timeframe]) for block in ccxt.binance({}).fetch_ohlcv(symbol = symbol, timeframe = timeframe, since = since, limit = data_limit): timestamp.append(block[0]) openx.append(block[1]) high.append(block[2]) low.append(block[3]) close.append(block[4]) volume.append(block[5]) n_bulk -= 1 if n_bulk > 0 or remainder > 0: time.sleep(api_cooldown_seconds) if remainder > 0: since = ccxt.binance({}).milliseconds() - (remainder * binance_timeframes[timeframe]) for block in ccxt.binance({}).fetch_ohlcv(symbol = symbol, timeframe = timeframe, since = since, limit = remainder): timestamp.append(block[0]) openx.append(block[1]) high.append(block[2]) low.append(block[3]) close.append(block[4]) volume.append(block[5]) data_identifier = 'binance_' + ''.join(symbol.split('/')) + '_' + str(timeframe) + '_' + str(length) + ('_including_current_candle' if include_current_candle == True else '_NOT_including_current_candle') if file_format != []: for ending in file_format: # specify where to save the files e.g. #with open('/Users/username/Desktop/' + data_identifier + '.' + str(ending), 'w') as csvfile: with open(data_identifier + '.' + str(ending), 'w') as csvfile: writer = csv.writer(csvfile, delimiter = ',', quotechar = '|', quoting = csv.QUOTE_MINIMAL) writer.writerow([head for head in ['Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume']]) if include_current_candle == True: write = zip(timestamp, openx, high, low, close, volume) if include_current_candle == False: write = zip(timestamp[:-1], openx[:-1], high[:-1], low[:-1], close[:-1], volume[:-1]) for entry in write: writer.writerow(entry) if include_current_candle == True: df = pd.DataFrame(list(zip(timestamp, openx, high, low, close, volume)), columns = ['Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume']) df.name = data_identifier return df if include_current_candle == False: df = pd.DataFrame(list(zip(timestamp[:-1], openx[:-1], high[:-1], low[:-1], close[:-1], volume[:-1])), columns = ['Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume']) df.name = data_identifier return df