def __init__(self): #try except #Initiate exchange data with objects for each exchange binance = ccxt.binance() bittrex = ccxt.bittrex() bitfinex = ccxt.bitfinex() kraken = ccxt.kraken() kucoin = ccxt.kucoin() #Dictionary with the ccxt objects self.exchanges = { 'binance': binance, 'bittrex': bittrex, 'bitfinex': bitfinex, 'kraken': kraken, 'kucoin': kucoin } #Get a list of tickers from Binance exchange to use throughout self.ticker_list = [] self.get_tickers_list() #CREATE A DATAFRAME FOR THE PRICE AND VOLUME DATA self.volume = pd.DataFrame(index=self.ticker_list, columns=list(self.exchanges.keys())) self.pricedf = pd.DataFrame(index=self.ticker_list, columns=list(self.exchanges.keys())) self.spread = pd.DataFrame(index=self.ticker_list, columns=list(self.exchanges.keys()))
def kuCoin(): symbol = 'DBC/ETH' exchange = ccxt.kucoin() markets = exchange.load_markets() ticker = exchange.fetch_ticker(symbol.upper()) print(ticker) avgPrice = (ticker['bid'] + ticker['ask']) / 2 print(avgPrice) return avgPrice
def load_exchange(): try: exchange = ccxt.kucoin() market = exchange.load_markets() except ccxt.RequestTimeout: time.sleep(DELAY) exchange, market = load_exchange() return exchange, market
def load_exchange(): try: exchange = ccxt.kucoin() market = exchange.load_markets() except ccxt.RequestTimeout: wait() exchange, market = load_exchange() return exchange, market
def load_exchange(): '''loads exchange and the market information. ''' try: exchange = ccxt.kucoin() market = exchange.load_markets() except ccxt.RequestTimeout: wait() exchange, market = load_exchange() return exchange, market
def get_kucoin_connection(key, secret): try: kucoin = ccxt.kucoin({ 'apiKey': key, 'secret': secret }) log("INFO", "Successfully established connection to KuCoin API") return kucoin except Exception as e: log("ERROR", f"Failed to establish connection to KuCoin API: {e}") return
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 load_exchange(): '''loads exchange and the market information. ''' try: exchange = ccxt.kucoin() market = exchange.load_markets() except (ccxt.RequestTimeout, ccxt.ExchangeError) as error: print("Be patient, we are trying to connect to the exchange.") print("In the mean while, check your internet connection.") print("Error:", error) wait() exchange, market = load_exchange() return exchange, market
def fetch_data(market_pair, total_days=365, timeframe='5m', exchange=ccxt.kucoin()): ohlcv_data = [] partial_list = [] time_end = datetime.datetime.now() api_parts = range(1, int(total_days / 5) + 1) for i in api_parts: days = 5 * i time_start = time_end - datetime.timedelta(days) time_start = int(time_start.timestamp() * 1000) partial_list = exchange.fetch_ohlcv(market_pair, timeframe, since=time_start) partial_list = list(reversed(partial_list)) ohlcv_data.extend(partial_list) clear_output() time_remaining = api_parts[-1] - i print('Slot ', i, ' was appended to the list ', market_pair, '. Only ', time_remaining, ' of ', api_parts[-1], ' to complete.', sep='') time.sleep( 5 ) # aumentar o número de segundos caso surja alta restrição de request/tempo no futuro ''' verifica último item para saber se alcançou início da API. 1505587800000 = Saturday, September 16, 2017 6:50:00 PM ''' if partial_list[-1][0] == 1505587800000: print('Extração de dados terminou.') break return ohlcv_data
def kucoinAgg(symbols): result = [] try: kucoin = ccxt.kucoin({ 'apiKey': 'apiKey', 'secret': 'secret', 'options': { 'adjustForTimeDifference': True } }) totalBalance = kucoin.fetch_balance()["free"] exchangeSymbols = kucoin.symbols checkSymbols = list(np.intersect1d(exchangeSymbols, symbols)) allData = kucoin.fetch_tickers(checkSymbols) ethPrice = kucoin.fetch_ticker("ETH/USDT")["last"] btcPrice = kucoin.fetch_ticker("BTC/USDT")["last"] for s in checkSymbols: try: quote = s.split("/")[-1] dataSymbols = allData[s] coinBalance = totalBalance.get(s.split("/")[0], 0) volume = int(float(dataSymbols["baseVolume"])) ask = dataSymbols["ask"] bid = dataSymbols["bid"] last = float(dataSymbols["last"]) if quote == "BTC": volume = int(volume * btcPrice * last) elif quote == "ETH": volume = int(volume * ethPrice * last) else: volume = int(volume * dataSymbols["last"]) volume = volume / ethPrice result.append(["kucoin", s, coinBalance, ask, bid, volume]) except: print("Kucoin couldn`t get " + s) continue except Exception as e: print(str(e)[:150]) return (result)
import pandas as pd ######## # Params ######## ccy = 'WAVES' ###### # Main ###### apiKey = API_KEYS_KU[0] apiSecret = API_SECRETS_KU[0] apiPassword = API_PASSWORDS_KU[0] d = { 'apiKey': apiKey, 'secret': apiSecret, 'password': apiPassword, 'enableRateLimit': True, 'nonce': lambda: ccxt.Exchange.milliseconds() } for proxy in PROXIES_KU: z = 'socks5://' + proxy + ':1080' print(z) d['proxies'] = {'http': z, 'https': z} ku = ccxt.kucoin(d) ku.options['recvWindow'] = 50000 df = pd.DataFrame( ku.futuresPrivate_get_positions()['data']).set_index('symbol') print(df.loc[ccy + 'USDTM']['currentQty'])
def is_trair(trair_candidate): # assuming that all currencies appear twice means we have a trair currency_counts = Counter(chain.from_iterable(trair_candidate)) return set(currency_counts.values()) == {2} def format_trairs(trairs): trair= [] for i in range(len(trairs)): t_trair = [] for j in range(len(trairs[i])): t_trair.append(trairs[i][j][0]+'/'+trairs[i][j][1]) print(t_trair) trair.append(t_trair) return (trair) exchange = ccxt.kucoin() market = exchange.load_markets() exchange_pairs = exchange.symbols raw_pairs = list(filter(lambda x: not '.d' in x, exchange_pairs)) pairs = map(parse_pair, raw_pairs) trair_candidates = combinations(pairs, r=3) #filter the actual trairs from all trair_candidates trairs = list(filter(is_trair,trair_candidates)) trair = format_trairs(trairs)
def update_withdrawal_fees(self, exchanges): """ Update withdrawal fees data on self_coin_list @exchanges: CoinList.BINANCE | CoinList.BITTREX | CoinList.POLONIEX """ bin_list, bit_list, polo_list = [], [], [] kraken_dict = {} if CoinList.BINANCE in exchanges: bin = BinanceAPIClient() bin_list = bin.get_withdrawal_fees() if CoinList.BITTREX in exchanges: bit = BittrexAPIClient() bit_list = bit.get_withdrawal_fees() if CoinList.POLONIEX in exchanges: polo = PoloniexAPIClient() polo_list = polo.get_withdrawal_fees() if CoinList.KRAKEN in exchanges: kraken = ccxt.kraken() kraken_dict = kraken.fees['funding']['withdraw'] if CoinList.KUCOIN in exchanges: kucoin = ccxt.kucoin() kucoin_dict = kucoin.fees['funding']['withdraw'] for coin in self.coin_list: for bin_coin in bin_list: if (coin.ticker == bin_coin['ticker']): coin.binance_fee = bin_coin['withdrawal_fee'] coin.binance_fee_usd = round( float(coin.binance_fee) * float(coin.price_usd), 2) break for bit_coin in bit_list: if (coin.ticker == bit_coin['ticker']): coin.bittrex_fee = bit_coin['withdrawal_fee'] coin.bittrex_fee_usd = round( float(coin.bittrex_fee) * float(coin.price_usd), 2) break for polo_coin in polo_list: if (coin.ticker == polo_coin['ticker']): coin.poloniex_fee = polo_coin['withdrawal_fee'] coin.poloniex_fee_usd = round( float(coin.poloniex_fee) * float(coin.price_usd), 2) break for key, value in kraken_dict.items(): if (coin.ticker == key): coin.kraken_fee = value coin.kraken_fee_usd = round( float(coin.kraken_fee) * float(coin.price_usd), 2) break for key, value in kucoin_dict.items(): if (coin.ticker == key): coin.kucoin_fee = value coin.kucoin_fee_usd = round( float(coin.kucoin_fee) * float(coin.price_usd), 2) break
plt.style.use ('seaborn-white') plt.rcParams["figure.figsize"] = [15,6] apiKey = "--------------------------------" #@param [""] {allow-input: true} secret = "---------------------------" #@param {type:"string"} subaccount = "---- main = 0 , subacc ---- " #@param ["---- main = 0 , subacc ---- "] {allow-input: true} password = "******" #@param ["----------------------"] {allow-input: true} exchange = ccxt.kucoin({ 'apiKey' :apiKey,'secret' : secret,'subaccount':subaccount,'password':password,'enbleRateLimit':True }) if subaccount == "0": print("This is Main Account") else: exchange.headers = { 'KUCOIN-SUBACCOUNT': subaccount, } #@title ฟังก์ชั่น คำนวนการใช้งาน def getBalance(): print("PORT BALANCE =",exchange.fetch_balance()) def getfreeCol(): freeCol = exchange.fetchFreeBalance()['result'][0]['free']
def KUM_with_ip_init(): return ccxt.kucoin({'apiKey': API_KEY_KUM_WITH_IP, 'secret': API_SECRET_KUM_WITH_IP, 'password': API_PASSWORD_KUM_WITH_IP, 'enableRateLimit': True, 'nonce': lambda: ccxt.Exchange.milliseconds()})
print('python', sys.version) print('CCXT Version:', ccxt.__version__) binance = ccxt.binance({ "apiKey": 'YOUR_BINANCE_API_KEY', "secret": 'YOUR_BINANCE_SECRET', 'options': { 'fetchCurrencies': True, }, }) binance.verbose = True kucoin = ccxt.kucoin({ 'apiKey': 'YOUR_KUCOIN_API_KEY', 'secret': 'YOUR_KUCOIN_SECRET', 'password': '******', }) kucoin.verbose = True binance.load_markets() kucoin.load_markets() code = 'USDT' amount = 40 params = {'network': 'TRC20'} deposit = binance.fetchDepositAddress(code, params) print('-----------------------------------------------------------')
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'], 'enableRateLimit': True, }) poloniex = ccxt.poloniex({ 'apiKey': api_keys.poloniex['apiKey'], 'secret': api_keys.poloniex['secret'], 'enableRateLimit': True, }) bittrex = ccxt.bittrex({ 'apiKey': api_keys.bittrex['apiKey'], 'secret': api_keys.bittrex['secret'], 'enableRateLimit': True, }) binance = ccxt.binance({ 'apiKey': api_keys.binance['apiKey'], 'secret': api_keys.binance['secret'], 'enableRateLimit': True, }) bitfinex = ccxt.bitfinex({ 'apiKey': api_keys.bitfinex['apiKey'], 'secret': api_keys.bitfinex['secret'], 'enableRateLimit': True, }) kucoin = ccxt.kucoin({ 'apiKey': api_keys.kucoin['apiKey'], 'secret': api_keys.kucoin['secret'], 'enableRateLimit': True, }) # kraken = ccxt.kraken({ # 'apiKey': api_keys.kraken['apiKey'], # 'secret': api_keys.kraken['secret'], # 'enableRateLimit': True, # }) bitmex = ccxt.bitmex({ 'apiKey': api_keys.bitmex['apiKey'], 'secret': api_keys.bitmex['secret'], 'enableRateLimit': True, }) okex = ccxt.okex({ 'apiKey': api_keys.okex['apiKey'], 'secret': api_keys.okex['secret'], 'enableRateLimit': True, }) exchanges = [ coinbasepro, poloniex, bittrex, binance, bitfinex, kucoin, bitmex, okex ] timing_limits = [.35, .35, 1, .35, 2, 1, 1, .35] # requesting period limit per exchange # timing_limits = [0, 0, 0, 0, 0, 0, 0, 0] # rateLimit Enabled on exchange for exchange, timing in zip(exchanges, timing_limits): g_storage.timer[exchange.name] = [0, timing] # exchanges.pop(exchanges.index(kraken)) return exchanges
binance = ccxt.binance({'enableRateLimit': True}) hitbtc = ccxt.hitbtc2({'enableRateLimit': True}) coinbasepro = ccxt.coinbasepro({ 'enableRateLimit': True, }) gemini = ccxt.gemini({ 'enableRateLimit': True, }) bitfinex = ccxt.bitfinex({ 'enableRateLimit': True, }) livecoin = ccxt.livecoin({ 'enableRateLimit': True, }) kucoin = ccxt.kucoin({ 'enableRateLimit': True, }) cex = ccxt.cex({ 'enableRateLimit': True, }) bitstamp = ccxt.bitstamp({ 'enableRateLimit': True, }) binance_ltc_address = 'LLmWdKju3aHzS8q5azoVGSfPV6NY6a4PvY' exmo_ltc_address = 'LThC9vNBvyJz7UesBAmpMaJNfHFhxXqhb6' #----------XRP------------ hitbtc_xrp_deposit_address = 'rhL5Va5tDbUUuozS9isvEuv7Uk1uuJaY1T' hitbtc_xrp_tag = '1492555998' exmo_xrp_deposit_address = 'rUocf1ixKzTuEe34kmVhRvGqNCofY1NJzV'
import ccxt import pandas as pd exchange = ccxt.kucoin({ 'apiKey': '********', 'secret': '************', 'password': '******', 'enableRateLimit': True, }) symbol = 'BNB/USDT' typee = 'limit' # or 'market' side = 'sell' # or 'buy' amount = 0.001 price = 20.00 # or None params = { 'recvWindow': 50000 } #order = exchange.fetch_my_trades(symbol ='BNB/USDT', params = params) #order = exchange.create_order(symbol, typee, side, amount, price, params) #print(type(order)) #print(order['id']) #print(order) #balance = exchange.fetch_balance(params) #df_balance = pd.DataFrame.from_dict(balance['info']['data']).set_index(['type', 'currency']) #df_balance['balance'] = df_balance.balance.astype(float) #print(df_balance.filter(like='trade', axis=0).loc[df_balance.balance > 0])
def init_supported_exchanges(): objects = { "acx": ccxt.acx(), "aofex": ccxt.aofex(), "bequant": ccxt.bequant(), "bibox": ccxt.bibox(), "bigone": ccxt.bigone(), "binance": ccxt.binance(), "bitbank": ccxt.bitbank(), "bitbay": ccxt.bitbay(), "bitfinex": ccxt.bitfinex(), "bitflyer": ccxt.bitflyer(), "bitforex": ccxt.bitforex(), "bithumb": ccxt.bithumb(), "bitkk": ccxt.bitkk(), "bitmax": ccxt.bitmax(), "bitstamp": ccxt.bitstamp(), "bittrex": ccxt.bittrex(), "bitz": ccxt.bitz(), "bl3p": ccxt.bl3p(), "bleutrade": ccxt.bleutrade(), "braziliex": ccxt.braziliex(), "btcalpha": ccxt.btcalpha(), "btcbox": ccxt.btcbox(), "btcmarkets": ccxt.btcmarkets(), "btctradeua": ccxt.btctradeua(), "bw": ccxt.bw(), "bybit": ccxt.bybit(), "bytetrade": ccxt.bytetrade(), "cex": ccxt.cex(), "chilebit": ccxt.chilebit(), "coinbase": ccxt.coinbase(), "coinbasepro": ccxt.coinbasepro(), "coincheck": ccxt.coincheck(), "coinegg": ccxt.coinegg(), "coinex": ccxt.coinex(), "coinfalcon": ccxt.coinfalcon(), "coinfloor": ccxt.coinfloor(), "coinmate": ccxt.coinmate(), "coinone": ccxt.coinone(), "crex24": ccxt.crex24(), "currencycom": ccxt.currencycom(), "digifinex": ccxt.digifinex(), "dsx": ccxt.dsx(), "eterbase": ccxt.eterbase(), "exmo": ccxt.exmo(), "exx": ccxt.exx(), "foxbit": ccxt.foxbit(), "ftx": ccxt.ftx(), "gateio": ccxt.gateio(), "gemini": ccxt.gemini(), "hbtc": ccxt.hbtc(), "hitbtc": ccxt.hitbtc(), "hollaex": ccxt.hollaex(), "huobipro": ccxt.huobipro(), "ice3x": ccxt.ice3x(), "independentreserve": ccxt.independentreserve(), "indodax": ccxt.indodax(), "itbit": ccxt.itbit(), "kraken": ccxt.kraken(), "kucoin": ccxt.kucoin(), "lakebtc": ccxt.lakebtc(), "latoken": ccxt.latoken(), "lbank": ccxt.lbank(), "liquid": ccxt.liquid(), "livecoin": ccxt.livecoin(), "luno": ccxt.luno(), "lykke": ccxt.lykke(), "mercado": ccxt.mercado(), "oceanex": ccxt.oceanex(), "okcoin": ccxt.okcoin(), "okex": ccxt.okex(), "paymium": ccxt.paymium(), "poloniex": ccxt.poloniex(), "probit": ccxt.probit(), "southxchange": ccxt.southxchange(), "stex": ccxt.stex(), "surbitcoin": ccxt.surbitcoin(), "therock": ccxt.therock(), "tidebit": ccxt.tidebit(), "tidex": ccxt.tidex(), "upbit": ccxt.upbit(), "vbtc": ccxt.vbtc(), "wavesexchange": ccxt.wavesexchange(), "whitebit": ccxt.whitebit(), "yobit": ccxt.yobit(), "zaif": ccxt.zaif(), "zb": ccxt.zb() } return objects
# -*- coding: utf-8 -*- import os import sys from pprint import pprint 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.kucoin({ 'apiKey': 'YOUR_API_KEY', 'secret': 'YOUR_API_SECRET', 'password': '******', }) markets = exchange.load_markets() exchange.verbose = True # uncomment for debugging purposes if necessary for code in ['TLOS']: # exchange.currencies.keys(): response = exchange.public_get_currencies_currency({'currency': code}) currency = exchange.safe_value(response, 'data') if currency: # pprint(currency) chains = exchange.safe_value(currency, 'chains') for chain in chains: chainName = exchange.safe_string(chain, 'chainName') try:
get_single_price(b, q, e) pairs.append(b + '-' + q) except PairNotListedError: pass return pairs def get_order_books(base, quote, client): """ Batch version of fetch order book ccxt function """ if isinstance(base, str): base = [base] if isinstance(quote, str): quote = [quote] order_books = {} for b in base: for q in quote: pair = b + '/' + q order_books[pair] = client.fetch_order_book(pair) # NOTE: order book lengths are different for different clients return order_books if __name__ == '__main__': ob = get_order_books('LTC', 'BTC', ccxt.kucoin())['LTC/BTC'] print(ob) print(len(ob['asks']), len(ob['bids']))
def run(self): self.client = Client(api_key=self.config['BINANCE']['KEY'], api_secret=self.config['BINANCE']['SECRET']) if self.args.mode == "trading": logger.info( "START TRADE | symbol: {}, btc amount: {}, targets: {}, stoploss price: {}, trailing: {}, trailing price: {}" .format(self.args.symbol, self.args.btc_amount, self.args.targets, self.args.immediate_stoploss, self.args.use_trailing, self.args.trailing_stoploss)) bm = BinanceSocketManager(self.client) self.conn_key = bm.start_symbol_ticker_socket( self.args.symbol, self.process_message) bm.start() elif self.args.mode == "analysis": alltickers = self.client.get_ticker() interval = "1h" exchange = ccxt.binance({ 'apiKey': self.config['BINANCE']['KEY'], 'secret': self.config['BINANCE']['SECRET'] }) for ticker in alltickers: if float(ticker['priceChangePercent']) > 2 and ( "BTC" in ticker['symbol']): data_base = exchange.fetch_ohlcv( ticker['symbol'].split("BTC")[0] + "/BTC", interval, limit=100) df = pd.DataFrame(data_base, columns=[ 'date', 'open', 'high', 'low', 'close', 'volume' ]) df["date"] = pd.to_datetime( df["date"], unit='ms').dt.strftime('%Y-%m-%d %H:%M') self.save_analysis(df, ticker['symbol'], interval, ticker['priceChangePercent']) elif self.args.mode == "hamster": mongo_client = MongoClient('mongodb://localhost:27017/') db = mongo_client.projectlife self.previous_response = "initial" timeout = 30 exchanges = dict() exchanges['binance'] = ccxt.binance({ 'apiKey': self.config['BINANCE']['KEY'], 'secret': self.config['BINANCE']['SECRET'] }) exchanges['kucoin'] = ccxt.kucoin({ 'apiKey': self.config['KUCOIN']['KEY'], 'secret': self.config['KUCOIN']['SECRET'] }) exchanges['bittrex'] = ccxt.bittrex({ 'apiKey': self.config['BITTREX']['KEY'], 'secret': self.config['BITTREX']['SECRET'] }) exchanges['poloniex'] = ccxt.poloniex() def doWork(): responses = [] try: url = 'https://www.mininghamster.com/api/v2/' + self.config[ 'HAMSTER']['API'] responses = requests.get(url).json() if len(responses) > 0: for response in responses: symbol = response['market'].split( "BTC-")[1] + "/BTC" bid, ask = self.get_prices( exchanges[response['exchange']], symbol) if response['signalmode'] == "buy": result_buy = db.hamster.find_one({ "signalID": response['signalID'], "signalmode": "buy" }) if result_buy == None: response['buy_price'] = ask db.hamster.insert_one(response) self.send_telegram(str(response)) elif response['signalmode'] == "sell": result_sell = db.hamster.find_one({ "signalID": response['signalID'], "signalmode": "sell" }) if result_sell == None: result_buy = db.hamster.find_one({ "signalID": response['signalID'], "signalmode": "buy" }) if result_buy != None: response['sell_price'] = bid response['profit'] = self.pct_change( result_buy['buy_price'], bid) db.hamster.insert_one(response) self.send_telegram(str(response)) except BaseException as e: print(e) pass lx = task.LoopingCall(doWork) lx.start(timeout) reactor.run() elif self.args.mode == "datacollect": client = MongoClient('mongodb://localhost:27017/') db = client.projectlife self.db_collection = db[self.args.symbol] bm = BinanceSocketManager(self.client) self.conn_key = bm.start_symbol_ticker_socket( self.args.symbol, self.process_datacollect_message) bm.start()
def exchangeObject(exchange_in): exchanges = [ ccxt.acx(), ccxt.bitbay(), ccxt.bitfinex(), ccxt.bitflyer(), ccxt.bithumb(), ccxt.bitlish(), ccxt.bitmarket(), ccxt.bitmex(), ccxt.bitso(), ccxt.bitstamp(), ccxt.bitstamp1(), ccxt.bittrex(), ccxt.bl3p(), ccxt.bleutrade(), ccxt.btcbox(), ccxt.btcchina(), ccxt.btcexchange(), ccxt.btcmarkets(), ccxt.btctradeua(), ccxt.btcturk(), ccxt.bxinth(), ccxt.ccex(), ccxt.cex(), ccxt.chbtc(), ccxt.chilebit(), ccxt.coincheck(), ccxt.coinfloor(), ccxt.coingi(), ccxt.coinmarketcap(), ccxt.coinmate(), ccxt.coinspot(), ccxt.cryptopia(), ccxt.dsx(), ccxt.exmo(), ccxt.flowbtc(), ccxt.foxbit(), ccxt.fybse(), ccxt.fybsg(), ccxt.gatecoin(), ccxt.gateio(), ccxt.gdax(), ccxt.gemini(), ccxt.getbtc(), ccxt.hitbtc(), ccxt.independentreserve(), ccxt.itbit(), ccxt.jubi(), ccxt.kraken(), ccxt.kucoin(), ccxt.kuna(), ccxt.lakebtc(), ccxt.liqui(), ccxt.livecoin(), ccxt.luno(), ccxt.mercado(), ccxt.mixcoins(), ccxt.nova(), ccxt.okcoincny(), ccxt.okcoinusd(), ccxt.okex(), ccxt.paymium(), ccxt.poloniex(), ccxt.qryptos(), ccxt.quadrigacx(), ccxt.southxchange(), ccxt.surbitcoin(), ccxt.therock(), ccxt.tidex(), ccxt.urdubit(), ccxt.vaultoro(), ccxt.vbtc(), ccxt.virwox(), ccxt.wex(), ccxt.xbtce(), ccxt.yobit(), ccxt.yunbi(), ccxt.zaif(), ccxt.zb() ] for count, exchange in enumerate([str(x) for x in exchanges]): if exchange_in.lower() in exchange: return exchanges[count] break
import ccxt import json import time import unicodecsv as csv from datetime import datetime #hitbtc = ccxt.hitbtc({'verbose': True}) #bitmex = ccxt.bitmex() #binance = ccxt.binance() exchanges = { 'coinmarketcap': ccxt.coinmarketcap(), 'binance': ccxt.binance(), 'bitmex': ccxt.bitmex(), 'bitfinex': ccxt.bitfinex(), 'kraken': ccxt.kraken(), 'kucoin': ccxt.kucoin(), 'hitbtc': ccxt.hitbtc({'verbose': True}) } with open('ccxt_data.csv', 'wb') as outfile: fieldnames = ["exchange", "symbol", "data"] schreiber = csv.DictWriter(outfile, fieldnames=fieldnames, encoding='utf-8') #schreiber.writeheader() for name, ex in exchanges.items(): exchange = ex exchange.load_markets() if exchange.has['fetchOHLCV']: for symbol in exchange.markets:
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'], 'enableRateLimit': True, }) cex = ccxt.cex({ 'apiKey': api_keys.cex['apiKey'], 'secret': api_keys.cex['secret'], 'enableRateLimit': True, }) poloniex = ccxt.poloniex({ 'apiKey': api_keys.poloniex['apiKey'], 'secret': api_keys.poloniex['secret'], 'enableRateLimit': True, }) bittrex = ccxt.bittrex({ 'apiKey': api_keys.bittrex['apiKey'], 'secret': api_keys.bittrex['secret'], 'enableRateLimit': True, }) binance = ccxt.binance({ 'apiKey': api_keys.binance['apiKey'], 'secret': api_keys.binance['secret'], 'enableRateLimit': True, }) bitfinex = ccxt.bitfinex({ 'apiKey': api_keys.bitfinex['apiKey'], 'secret': api_keys.bitfinex['secret'], 'enableRateLimit': True, }) kucoin = ccxt.kucoin({ 'apiKey': api_keys.kucoin['apiKey'], 'secret': api_keys.kucoin['secret'], 'enableRateLimit': True, }) kraken = ccxt.kraken({ 'apiKey': api_keys.kraken['apiKey'], 'secret': api_keys.kraken['secret'], 'enableRateLimit': True, 'options': { # ←--------------------- inside 'options' subkey 'fetchMinOrderAmounts': False, # ←---------- set to False } }) bitmex = ccxt.bitmex({ 'apiKey': api_keys.bitmex['apiKey'], 'secret': api_keys.bitmex['secret'], 'enableRateLimit': True, }) okex = ccxt.okex({ 'apiKey': api_keys.okex['apiKey'], 'secret': api_keys.okex['secret'], 'enableRateLimit': True, }) exchanges = [ coinbasepro, cex, poloniex, bittrex, binance, bitfinex, kucoin, kraken, okex, bitmex ] return exchanges
token_to_prices = calculate_token_to_prices( bittrex, token_to_markets, bittrex_btc_usd_last, bittrex_eth_usd_last, bittrex_eth_btc_last, bittrex_all_tickers ) token_exchanges = generate_token_exchanges('bittrex', token_to_prices) update_token_exchanges(token_exchanges) ### Kucoin ### kucoin = ccxt.kucoin() kucoin_all_tickers = kucoin.fetchTickers() kucoin_btc_usd_last = kucoin_all_tickers['BTC/USDT']['last'] kucoin_eth_usd_last = kucoin_all_tickers['ETH/USDT']['last'] kucoin_eth_btc_last = kucoin_all_tickers['ETH/BTC']['last'] token_to_markets = parse_tokens_to_markets(kucoin.fetchMarkets()) token_to_prices = calculate_token_to_prices( kucoin, token_to_markets, kucoin_btc_usd_last, kucoin_eth_usd_last, kucoin_eth_btc_last, kucoin_all_tickers )
import ccxt import pandas as pd exchange = ccxt.kucoin({ 'apiKey': '5f06d59e3988760006e3efbd', 'secret': '35f65889-d94b-4f57-b930-bbb3940784bc', 'password': '******' }) #def ordercreate(status,amount,price): # exchange.create_order('BNB/USDT','limit',status,amount,price) #print(exchange.fetch_balance ()) #look at how much balance #print(exchange.fetch_total_balance()) #print(exchange.fetch_ticker('BNB/USD')['last']) #ordercreate('buy',0.001,16.0)
# -*- 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.kucoin({ "apiKey": "YOUR_API_KEY", "secret": "YOUR_SECRET", "password": "******" }) symbol = 'ETH/USDT' now = exchange.milliseconds() day = 24 * 3600 * 1000 week = 7 * day since = now - 365 * day # start one year back limit = 20 while since < now: end = min(since + week, now) params = {'endAt': end} orders = exchange.fetch_closed_orders(symbol, since, limit, params) print(exchange.iso8601(since), '-', exchange.iso8601(end), len(orders), 'orders')
def calc(): bitfinex = ccxt.bitfinex() marketsBf = bitfinex.load_markets() cex = ccxt.cex() kucoin = ccxt.kucoin() poloniex = ccxt.poloniex() bittrex = ccxt.bittrex() FEE = 1.02 # fee for every trade (2%) Diff = 0.6 # 1 % arbitrage to execute curr = [ "ETH/BTC", "OMG/BTC", "LTC/BTC", "DASH/BTC", "ETC/BTC", "OMG/BTC" ] # "LTC/BTC", "DASH/BTC", "ETC/BTC", "OMG/BTC", "BCH/BTC" currencies to trade if arbitrage is found exc = [ bitfinex, kucoin, bittrex, cex ] # cex ,kucoin , bittrex exchanges to trade on for the function calls def getAsk(market, sym): orderbook = market.fetch_order_book(sym) ask = orderbook['asks'][0][0] if len(orderbook['asks']) > 0 else None return ask def getBid(market, sym): orderbook = market.fetch_order_book(sym) bid = orderbook['bids'][0][0] if len(orderbook['bids']) > 0 else None return bid def compare(): print("Arbitrage Trader starting up...") yon_file = open("yon.txt", "r") yon = yon_file.read() yon_file.close n = 0 while n <= (len(curr) - 1): print("Starting Arbitrage checking for ", curr[n]) pairpart1 = curr[n] m = 0 while m <= (len(exc) - 1): #print "m = " + str(m) k = 0 while k <= (len(exc) - 1): #print "k = " + str(k) try: if (yon == "1"): sprice = getBid(exc[m], curr[n]) bprice = getAsk(exc[k], curr[n]) else: sprice = getBid(exc[k], curr[n]) bprice = getAsk(exc[m], curr[n]) except Exception: pass #print ("Sell price = " , str(sprice) , " on " , exc[m].id) #print ("Buy price = " , str(bprice) , " on " , exc[k].id) if (float(bprice) < float(sprice)): #print ("Opportunity to buy " , curr[n] , " for ", str(bprice), " on ",exc[k]," and sell for " , str(sprice) , " on " , exc[m]) yie = ((float(sprice) - float(bprice)) / float(sprice)) * 100.0 #print ("Yield before trading costs would be: ",str(yie),"%") if (((float(sprice) - float(bprice)) / float(sprice)) * 100.0 > Diff): # make_trade(exc[k], "buy", amount1, pairpart1, "btc", bprice) # make_trade(exc[m], "sell", amount1, pairpart1, "btc", sprice) #printouts for debugging print("price on ", exc[m].id, " for ", curr[n], " is ", str(sprice), " BTC") print("price on ", exc[k].id, " for ", curr[n], " is ", str(bprice), " BTC") print( "executing trade at a win per 1", curr[n], " of ", str( round(((sprice * 0.998) - (bprice * 1.002004)), 8)), "BTC") profit = str( round( 100 * (((sprice + bprice) + (sprice * 0.998) - bprice * 1.002004) - (sprice + bprice)) / (sprice + bprice), 2)) print("profit %", profit) with open("log.txt", "a") as text_file: print( f"{curr[n]} {exc[m].id} {sprice} Sell", file=text_file) print( f"{curr[n]} {exc[k].id} {bprice} Buy", file=text_file) print( f"-{exc[k].id}'den alındı {exc[m].id} 'de satıldı-----yön:{yon}------- Profit % {profit}\n", file=text_file) print(f" yön: {yon}") text_file.close yon_filer = open("yon.txt", "w") if yon == "1": yon_filer.write("0") else: yon_filer.write("1") yon_filer.close k += 1 m += 1 n += 1 compare()