python-Binance api: APIError(code=-1013): Filter failure: LOT_SIZE

Question

嘗試使用 python-binance api 下買賣訂單時，出現以下錯誤：

APIError(code=-1013): Filter failure: LOT_SIZE.

現在我在iceberg_parts看到這意味着我的買賣數量可能有問題。 我試圖將數量增加 10 倍，但這只會給我另一個相關的錯誤：

APIError(code=-1013): Filter failure: MIN_NOTIONAL.

這是我的一些代碼：

diff = current_price - prev_price
if diff <= 0.0001:
    order = client.order_market_buy(symbol = market , quantity = '0.0001')
    print('buy order')

if diff >= 0.00040:
    order = client.order_market_sell(symbol =market, quantity ='0.0001')
    print('sell order')

你知道如何解決這個問題嗎？

Answer 1

出現此錯誤是因為您嘗試創建數量低於所需最小值的訂單。

您可以通過以下方式訪問特定對所需的最小值：

info = client.get_symbol_info('ETHUSDT')
print(info)

Output 包含有關該對的信息的字典。 現在您可以通過以下方式訪問所需的最小數量：

print(info['filters'][2]['minQty'])
# 0.00001

Answer 2

買入或賣出數量必須 >= 10.3 美元或 10.3/價格，將數量和價格傳遞給這些小數設置/過濾器，金額設置為小數

from decimal import Decimal as D, ROUND_DOWN, ROUND_UP
import decimal

info = client.get_symbol_info(symbol=pair)
price_filter = float(info['filters'][0]['tickSize'])
ticker = client.get_symbol_ticker(symbol=pair)
price = float(ticker['price'])
price = D.from_float(price).quantize(D(str(price_filter)))
minimum = float(info['filters'][2]['minQty']) # 'minQty'
quant = D.from_float(quantity).quantize(D(str(minimum))) # if quantity >= 10.3/price

Answer 3

我剛剛經歷了同樣的問題。 作為菜鳥，這些答案中的一些代碼似乎很復雜，所以我想出了一個解決方案。

代碼：

def check_decimals(symbol):
    info = client.get_symbol_info(symbol)
    val = info['filters'][2]['stepSize']
    decimal = 0
    is_dec = False
    for c in val:
        if is_dec is True:
            decimal += 1
        if c == '1':
            break
        if c == '.':
            is_dec = True
    return decimal

然后當您下訂單時，只需執行 ex: (確保 qty 是浮點數或小數)

  B_order = round(qty / symbol_price, decimal)
  order = client.order_market_buy(
            symbol=symbol_name,
            quantity=B_order)

Answer 4

這是一些代碼。

def round_down(self, coin, number):
    info = self.client.get_symbol_info('%sUSDT' % coin)
    step_size = [float(_['stepSize']) for _ in info['filters'] if _['filterType'] == 'LOT_SIZE'][0]
    step_size = '%.8f' % step_size
    step_size = step_size.rstrip('0')
    decimals = len(step_size.split('.')[1])
    return math.floor(number * 10 ** decimals) / 10 ** decimals

Answer 5

最小數量相當於 10 USDT。 另請注意，每個硬幣都有自己的最大允許十進制數字。 即對於 USDT，它是 2，因此，例如，如果您嘗試交易 10.0002，它將被四舍五入為 10.00。 此外，當 Binance 驗證金額看起來以當前匯率轉換為 USDT 時，您的硬幣的最低數量將始終不同，您需要在您的代碼中確保您指定的數量在您的那一刻大於 10 USDT要求。 我還額外增加了 1-3% 的金額，以確保它將成功通過驗證，因為在我發送請求的那一刻和它通過驗證的那一刻之間，費率可能會發生變化。 因此，當我想以最低允許數量進行交易時，我交易的金額約為 10.30 USDT。

Answer 6

https://python-binance.readthedocs.io/en/latest/account.html

from binance.helpers import round_step_size

# to get a lot size
def getLotSize(self):
    info = self.apiCall(lambda: self.client.get_symbol_info(self.pair))
    lotSize = float(info['filters'][2]['minQty'])
    return lotSize


# get ceiling value and correct format for a lot size
def getCeilingVal(self):
    pairData = self.apiCall(lambda: 
    self.client.get_symbol_ticker(symbol=self.pair))
    pairPrice = pairData["price"]
    ceilingVal = float(self.dInv) / float(pairPrice)

    aLotSize = self.getLotSize()
    rounded_amount = round_step_size(ceilingVal, aLotSize)

    return rounded_amount

Answer 7

這是使用 binance-python package 的非常有用的代碼

  ...
  // Full code: https://github.com/ndiecodes/binance-trading-bot/blob/main/main.py

  def get_round_step_quantity(self, qty):
    info = self.client.get_symbol_info(Config.TRADESYMBOL)
    for x in info["filters"]:
        if x["filterType"] == "LOT_SIZE":
            self.minQty = float(x["minQty"])
            self.maxQty = float(x["maxQty"])
            self.stepSize= float(x["stepSize"])
    if qty < self.minQty:
        qty = self.minQty
    return round_step_size(quantity=qty, step_size=self.stepSize)

Answer 8

我已經閱讀了所有這些論壇問題，沒有人提到幣安對所有交易收取0.1%的費用這一事實。 這意味着當觸發賣出時，您沒有可用於回售的原始購買數量。

我試圖解決這個問題：

buy_quantity = round(buy_amount * 0.999, len(str(lotsize).split('.')[1]))

將我的原始購買數量乘以0.999應該會減少能夠賣回所需的數量。

Answer 9

嗨，如果我有 20 美元要購買，請在@stack 上再添加一點，那么我的數量如下

我已經完成了如下

    decimal_places=abs(Decimal(symbl_info['filters'][2]["stepSize"]).normalize().as_tuple().exponent)
print("DECIMAL PLACES {0}".format(decimal_places))
buy_qauntity= round((20/order_input["askPrice"].values[0]),decimal_places)
print(buy_qauntity)

Answer 10

嘗試使用 Multicharts-binance api 下買入或賣出訂單時，出現以下錯誤：{"code":-1013, "msg": "Filter failure: MIN_NOTIOLNAL"}

Answer 11

也許這可以解釋為什么服務器返回這個錯誤。

過濾器

從端點GET /api/v3/exchangeInfo ，您可以找到有關交易品種的所有詳細信息。 它包括客戶下訂單需要遵循的許多過濾器。 例如， BTCUSDT從今天開始有過濾器（2022-08-31）

"filters": [
    {
        "filterType": "PRICE_FILTER",
        "minPrice": "0.01000000",
        "maxPrice": "1000000.00000000",
        "tickSize": "0.01000000"
    },
    {
        "filterType": "PERCENT_PRICE",
        "multiplierUp": "5",
        "multiplierDown": "0.2",
        "avgPriceMins": 5
    },
    {
        "filterType": "LOT_SIZE",
        "minQty": "0.00001000",
        "maxQty": "9000.00000000",
        "stepSize": "0.00001000"
    },
    {
        "filterType": "MIN_NOTIONAL",
        "minNotional": "10.00000000",
        "applyToMarket": true,
        "avgPriceMins": 5
    },
    {
        "filterType": "ICEBERG_PARTS",
        "limit": 10
    },
    {
        "filterType": "MARKET_LOT_SIZE",
        "minQty": "0.00000000",
        "maxQty": "282.39806510",
        "stepSize": "0.00000000"
    },
    {
        "filterType": "TRAILING_DELTA",
        "minTrailingAboveDelta": 10,
        "maxTrailingAboveDelta": 2000,
        "minTrailingBelowDelta": 10,
        "maxTrailingBelowDelta": 2000
    },
    {
        "filterType": "MAX_NUM_ORDERS",
        "maxNumOrders": 200
    },
    {
        "filterType": "MAX_NUM_ALGO_ORDERS",
        "maxNumAlgoOrders": 5
    }
]

LOT_SIZE 驗證

最小數量

如果你在這個BTCUSDT ，帶有參數：

price=19000
side=BUY
type=LIMIT
quantity=0.000005

這是一個LIMIT BUY訂單， price為 $19,000，但quantity少於minQty中的LOT_SIZE ：

0.000005 < 0.00001000

那么服務器將拒絕該訂單，因為該請求無法通過此過濾器驗證。

---

✗ LOT_SIZE 。 minQty

步長

我可以使用相同的參數下訂單，但只將quantity更改為 0.000015 嗎？ 那是：

price=19000
side=BUY
type=LIMIT
quantity=0.000015

您仍然會收到此錯誤，因為數量無法通過 stepSize 大小驗證： ( quantity - minQty ) % stepSize == 0

(0.000015 - 0.00001) % 0.00001 != 0

---

✓ LOT_SIZE 。 minQty
✗ LOT_SIZE 。 stepSize

MIN_NOTIONAL 驗證

好吧，讓我們將quantity更改為0.00002 ，使用相同的參數：

price=19000
side=BUY
type=LIMIT
quantity=0.00002

由於無法通過過濾器MIN_NOTIONAL驗證，該訂單仍將被拒絕並出現不同的錯誤。

19000 x 0.00002 = 0.38 < 10 ( MIN_NOTIONAL . minNotional )

筆記：

• minNotional定義每個訂單所需的最小名義價值。
• 對於MARKET訂單，使用最后avgPriceMins分鍾的平均價格。

---

✓ LOT_SIZE 。 minQty
✓ LOT_SIZE 。 stepSize
✗ MIN_NOTIONAL 。 minNotional

Answer 12

我這樣寫了一個 function 。 它對我有用。

def getPriceLotFormat(self, priceOrg, quantityOrg):
    price = float(priceOrg)
    quantity = float(quantityOrg)
    response = self.get_symbol_info(car.pair) #self is client btw
    priceFilterFloat = format(float(response["filters"][0]["tickSize"]), '.20f')
    lotSizeFloat = format(float(response["filters"][2]["stepSize"]), '.20f')
    # PriceFilter
    numberAfterDot = str(priceFilterFloat.split(".")[1])
    indexOfOne = numberAfterDot.find("1")
    if indexOfOne == -1:
        price = int(price)
    else:
        price = round(float(price), int(indexOfOne - 1))
    # LotSize
    numberAfterDotLot = str(lotSizeFloat.split(".")[1])
    indexOfOneLot = numberAfterDotLot.find("1")
    if indexOfOneLot == -1:
        quantity = int(quantity)
    else:
        quantity = round(float(quantity), int(indexOfOneLot))
    print(f"""
    ##### SELL #####
    Pair : {str(car.pair)}
    Cash : {str(car.price)}
    Quantity : {str(car.quantity)}
    Price : {str(car.price)}
        """)

Answer 13

我們可以使用 Log10 function 從 Binance /api/v3/exchangeinfo 端點數據中獲取舍入精度。

CurrencyRoundNum = int(math.Abs(math.Log10(stepSize)))
PriceRoundNum = int(math.Abs(math.Log10(tickSize)))

golang 的完整版本在這里，或者在 go 操場上。 很抱歉，代碼不在 python 上。

Answer 14

所以我自己也在努力解決 LOT_SIZE 錯誤。

以前我使用的是 python-binance 庫中的 round_step_size function，但是，我必須編輯這個 function 來處理這個 API 錯誤。

這是我使用的 function：

from decimal import Decimal, ROUND_DOWN
import math
from typing import Union

def round_step_size(quantity: Union[float, Decimal], step_size: Union[float, Decimal]) -> float:
    if step_size == 1.0:
        return math.floor(quantity)
    elif step_size < 1.0:
        return Decimal(f'{quantity}').quantize(Decimal(f'{step_size}'), rounding=ROUND_DOWN)