I get some errors. Please help me

API Futures API
1

2024-07-30 02:02:57,274 - ERROR - Long pozisyon açma hatası: 400, {“code”:-1022,“msg”:“Signature for this request is not
valid.”}

2

Hey,
Have a look at this post: FAQ: Signature for this request is not valid.

1 Like
3

Check the below and Try:

Ensure that the API secret key used to sign your requests is correct and matches what you have in your Binance API management.

Ensure that the parameters are being formatted correctly and concatenated in the right order before hashing.

Make sure you are using the correct method (e.g., HMAC SHA256) for generating the signature.

Check that the timestamp parameter is within an acceptable range (usually a few seconds of the server time). If your system clock is off, it might cause issues.

Use the Binance API’s /api/v1/time endpoint to fetch the server time and adjust your request accordingly.

All parameter values need to be URL encoded before being concatenated into the query string used to create the signature.

Make sure you include the API key in the request headers correctly.

Confirm that you’re using the correct HTTP method (GET, POST, etc.) as required by the endpoint.

See the example code below, if it helps…

import requests
import hashlib
import hmac
import time
from urllib.parse import urlencode

api_key = ‘your_api_key’
api_secret = ‘your_api_secret’

base_url = ‘https://api.binance.com’

#Endpoint example
endpoint = ‘/api/v3/order’

#parameters

params = {
‘symbol’: ‘BTCUSDT’,
‘side’: ‘BUY’,
‘type’: ‘MARKET’,
‘quantity’: 0.01,
‘timestamp’: int(time.time() * 1000)
}

URL ENCODING

query_string = urlencode(params)

signature

signature = hmac.new(api_secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()
params[‘signature’] = signature

URL

url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

Header

headers = {
‘X-MBX-APIKEY’: api_key
}

Making the request

response = requests.post(url, headers=headers, params=params)
print(response.text)

Refer to the link provided by @albin

Consider using tools like Postman to manually generate and test your API requests. This can help you understand how parameters and signatures are formed.

6

Can you check the my code if you have free time please ?
I’m working on it from one month
I’m ready to pay som money

7

Hi Aref,

I can check the codes, no need for money or anything.

1 Like
8

Thats awesome :clap: thank you so much

9

I don’t want to share my strategy on online for public

So can you give me whatsapp or email

10

import hashlib
import time
import requests
import logging
import hmac
from urllib.parse import urlencode

API anahtarları ve sırrı

api_key = ‘AEBjCNB4tu7MZLz0JpBEUb3bgixj8UbmHpwrJP2f1PfOZI4Nb9b4VpMERUktpPH6’
api_secret = ‘JiPpp7QZbXQcyol7VJUXab35qTgQC3yPFORs7CSNfnZFQUkWhB3ghgRAFd2lFbHh’

Binance API URL’si

base_url = “https://dapi.binance.com” # Coin-M Futures API için base URL

Logging ayarları

logging.basicConfig(level=logging.INFO) # INFO seviyesinde loglama
logger = logging.getLogger(name)

def create_signature(params, secret):
# Parametreleri alfabetik sıraya göre sıralayıp birleştiriyoruz
query_string = urlencode(sorted(params.items()))
# HMAC-SHA256 algoritması ile imza oluşturuyoruz
return hmac.new(secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()

def get_ohlc_data(symbol, interval=‘1m’, limit=2):
endpoint = ‘/dapi/v1/klines’
url = base_url + endpoint
params = {
‘symbol’: symbol,
‘interval’: interval,
‘limit’: limit
}
response = requests.get(url, params=params)
if response.status_code == 200:
try:
return response.json()
except ValueError as e:
logger.error(“JSON çözümleme hatası: %s”, e)
logger.error(“Yanıt içeriği: %s”, response.text)
time.sleep(1) # 1 saniye bekleme
return None
else:
logger.error(“OHLC verisi alma hatası: %d, %s”, response.status_code, response.text)
time.sleep(1) # 1 saniye bekleme
return None

def get_position_size(symbol):
endpoint = ‘/dapi/v1/positionRisk’
url = base_url + endpoint
params = {
‘symbol’: symbol,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.get(url, headers=headers, params=params)

if response.status_code == 200:
    try:
        positions = response.json()
        for pos in positions:
            if pos['symbol'] == symbol:
                return float(pos['positionAmt'])
    except ValueError as e:
        logger.error("JSON çözümleme hatası: %s", e)
        logger.error("Yanıt içeriği: %s", response.text)
        return 0
else:
    logger.error("Pozisyon verisi alma hatası: %d, %s", response.status_code, response.text)
    return 0

def open_long_position(symbol, quantity):
endpoint = ‘/dapi/v1/order’
url = base_url + endpoint

params = {
    'symbol': symbol,
    'side': 'BUY',
    'type': 'MARKET',
    'quantity': quantity,
    'timestamp': int(time.time() * 1000)
}
params['signature'] = create_signature(params, api_secret)
headers = {'X-MBX-APIKEY': api_key}
response = requests.post(url, headers=headers, params=params)

if response.status_code == 200:
    try:
        logger.info("Long pozisyon açıldı: %s", response.json())
        return True
    except ValueError as e:
        logger.error("JSON çözümleme hatası: %s", e)
        logger.error("Yanıt içeriği: %s", response.text)
        return False
else:
    logger.error("Long pozisyon açma hatası: %d, %s", response.status_code, response.text)
    return False

def open_short_position(symbol, quantity):
endpoint = ‘/dapi/v1/order’
url = base_url + endpoint

params = {
    'symbol': symbol,
    'side': 'SELL',
    'type': 'MARKET',
    'quantity': quantity,
    'timestamp': int(time.time() * 1000)
}
params['signature'] = create_signature(params, api_secret)
headers = {'X-MBX-APIKEY': api_key}
response = requests.post(url, headers=headers, params=params)

if response.status_code == 200:
    try:
        logger.info("Short pozisyon açıldı: %s", response.json())
        return True
    except ValueError as e:
        logger.error("JSON çözümleme hatası: %s", e)
        logger.error("Yanıt içeriği: %s", response.text)
        return False
else:
    logger.error("Short pozisyon açma hatası: %d, %s", response.status_code, response.text)
    return False

def close_positions(symbol, position_type):
endpoint = ‘/dapi/v1/order’
url = base_url + endpoint

position_quantity = abs(get_position_size(symbol))  # Pozisyon büyüklüğünü dinamik olarak alıyoruz
if position_quantity == 0:
    logger.info("Kapacak pozisyon bulunamadı.")
    return False

side = 'SELL' if position_type == 'long' else 'BUY'
params = {
    'symbol': symbol,
    'side': side,
    'type': 'MARKET',
    'quantity': position_quantity,
    'timestamp': int(time.time() * 1000)
}
params['signature'] = create_signature(params, api_secret)
headers = {'X-MBX-APIKEY': api_key}
response = requests.post(url, headers=headers, params=params)

if response.status_code == 200:
    try:
        logger.info("Pozisyon kapatıldı: %s", response.json())
        return True
    except ValueError as e:
        logger.error("JSON çözümleme hatası: %s", e)
        logger.error("Yanıt içeriği: %s", response.text)
        return False
else:
    logger.error("Pozisyon kapama hatası: %d, %s", response.status_code, response.text)
    return False

def monitor_price(symbol, threshold_pct):
lowest_price = float(‘inf’)
highest_price = 0
position_open = None
entry_price = None
quantity = 1

logger.info("Bot çalışıyor!")

while True:
    ohlc_data = get_ohlc_data(symbol, '1m', 2)
    if ohlc_data is None:
        logger.info("Veri alınamadı, 30 saniye bekleniyor.")
        time.sleep(30)
        continue

    current_price = float(ohlc_data[-1][4])
    if current_price < lowest_price:
        lowest_price = current_price
    if current_price > highest_price:
        highest_price = current_price

    # Yüzde değişim hesaplamaları
    price_change_pct_up = ((current_price - lowest_price) / lowest_price) * 100
    price_change_pct_down = ((current_price - highest_price) / highest_price) * 100

    # Kar/Zarar hesaplama
    if position_open is not None:
        if position_open == 'long':
            profit_loss = (current_price - entry_price) * quantity
        elif position_open == 'short':
            profit_loss = (entry_price - current_price) * quantity
    else:
        profit_loss = 0

    # Mevcut kar/zarar ve pozisyon açılmaya kalan değişim
    if position_open:
        if position_open == 'long':
            remaining_pct = max(threshold_pct - price_change_pct_up, 0)
        elif position_open == 'short':
            remaining_pct = max(threshold_pct - price_change_pct_down, 0)
    else:
        remaining_pct = threshold_pct

    # Basit ve anlaşılır çıktı
    logger.info(f"Mevcut Fiyat: {current_price:.2f} USDT | "
                f"Yüzde Değişim Yukarı: {price_change_pct_up:.2f}% | "
                f"Yüzde Değişim Aşağı: {price_change_pct_down:.2f}% | "
                f"Kalan Yüzde: {remaining_pct:.2f}% | "
                f"Kar/Zarar: {profit_loss:.2f} USDT")

    if price_change_pct_up >= threshold_pct:
        if position_open != 'long':
            logger.info("Fiyat %0.2f%% yukarı hareket etti. Long pozisyon açılıyor.", price_change_pct_up)
            if position_open == 'short':
                close_positions(symbol, 'short')
            if open_long_position(symbol, quantity):
                position_open = 'long'
                entry_price = current_price
                lowest_price = current_price
                highest_price = current_price
    elif price_change_pct_down >= threshold_pct:
        if position_open != 'short':
            logger.info("Fiyat %0.2f%% aşağı hareket etti. Short pozisyon açılıyor.", price_change_pct_down)
            if position_open == 'long':
                close_positions(symbol, 'long')
            if open_short_position(symbol, quantity):
                position_open = 'short'
                entry_price = current_price
                highest_price = current_price
                lowest_price = current_price

    time.sleep(1)  # 1 saniye bekleme

if name == “main”:
symbol = ‘BTCUSD_PERP’ # Sembolü BTCUSD_PERP olarak ayarlıyoruz
threshold_pct = 0.079
monitor_price(symbol, threshold_pct)

This is my code

11

test the below and if error share the full error, use traceback…

import hashlib
import time
import requests
import logging
import hmac
import traceback
from urllib.parse import urlencode

API keys and secret

api_key = ‘DONT SHARE API’
api_secret = ‘DONT SHARE API’

Binance API URL

base_url = “https://dapi.binance.com”

Logging settings

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

def create_signature(params, secret):
# Sort parameters alphabetically and concatenate
query_string = urlencode(sorted(params.items()))
# Create a HMAC-SHA256 signature
return hmac.new(secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()

def get_ohlc_data(symbol, interval=‘1m’, limit=2):
endpoint = ‘/dapi/v1/klines’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘interval’: interval,
‘limit’: limit
}
response = requests.get(url, params=params)
if response.status_code == 200:
try:
return response.json()
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
time.sleep(1)
return None
else:
logger.error(“Failed to retrieve OHLC data: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
time.sleep(1)
return None

def get_position_size(symbol):
endpoint = ‘/dapi/v1/positionRisk’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.get(url, headers=headers, params=params)
if response.status_code == 200:
try:
positions = response.json()
for pos in positions:
if pos[‘symbol’] == symbol:
return float(pos[‘positionAmt’])
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
return 0
else:
logger.error(“Failed to retrieve position data: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
return 0

def open_long_position(symbol, quantity):
endpoint = ‘/dapi/v1/order’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘side’: ‘BUY’,
‘type’: ‘MARKET’,
‘quantity’: quantity,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.post(url, headers=headers, params=params)
if response.status_code == 200:
try:
logger.info(“Long position opened: %s”, response.json())
return True
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
return False
else:
logger.error(“Failed to open long position: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
return False

def open_short_position(symbol, quantity):
endpoint = ‘/dapi/v1/order’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘side’: ‘SELL’,
‘type’: ‘MARKET’,
‘quantity’: quantity,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.post(url, headers=headers, params=params)
if response.status_code == 200:
try:
logger.info(“Short position opened: %s”, response.json())
return True
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
return False
else:
logger.error(“Failed to open short position: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
return False

def close_positions(symbol, position_type):
position_quantity = abs(get_position_size(symbol))
if position_quantity == 0:
logger.info(“No position found to close.”)
return False

side = 'SELL' if position_type == 'long' else 'BUY'
endpoint = '/dapi/v1/order'
url = f"{base_url}{endpoint}"
params = {
    'symbol': symbol,
    'side': side,
    'type': 'MARKET',
    'quantity': position_quantity,
    'timestamp': int(time.time() * 1000)
}
params['signature'] = create_signature(params, api_secret)
headers = {'X-MBX-APIKEY': api_key}
response = requests.post(url, headers=headers, params=params)
if response.status_code == 200:
    try:
        logger.info("Position closed: %s", response.json())
        return True
    except ValueError as e:
        logger.error("JSON parsing error: %s", e)
        logger.error(traceback.format_exc())
        return False
else:
    logger.error("Failed to close position: %d, %s", response.status_code, response.text)
    logger.error(traceback.format_exc())
    return False

def monitor_price(symbol, threshold_pct):
lowest_price = float(‘inf’)
highest_price = 0
position_open = None
entry_price = None
quantity = 1

logger.info("Bot is running!")
while True:
    ohlc_data = get_ohlc_data(symbol, '1m', 2)
    if ohlc_data is None:
        logger.info("Data retrieval failed, waiting for 30 seconds.")
        time.sleep(30)
        continue

    current_price = float(ohlc_data[-1][4])
    if current_price < lowest_price:
        lowest_price = current_price
    if current_price > highest_price:
        highest_price = current_price

    # Percentage change calculations
    price_change_pct_up = ((current_price - lowest_price) / lowest_price) * 100
    price_change_pct_down = ((current_price - highest_price) / highest_price) * 100

    # Profit/Loss calculation
    if position_open is not None:
        if position_open == 'long':
            profit_loss = (current_price - entry_price) * quantity
        elif position_open == 'short':
            profit_loss = (entry_price - current_price) * quantity
    else:
        profit_loss = 0

    # Remaining percentage and position opening conditions
    if position_open:
        if position_open == 'long':
            remaining_pct = max(threshold_pct - price_change_pct_up, 0)
        elif position_open == 'short':
            remaining_pct = max(threshold_pct - price_change_pct_down, 0)
    else:
        remaining_pct = threshold_pct

    logger.info(f"Current Price: {current_price:.2f} USDT | "
                f"Percentage Change Up: {price_change_pct_up:.2f}% | "
                f"Percentage Change Down: {price_change_pct_down:.2f}% | "
                f"Remaining Percentage: {remaining_pct:.2f}% | "
                f"Profit/Loss: {profit_loss:.2f} USDT")

    if price_change_pct_up >= threshold_pct:
        if position_open != 'long':
            logger.info("Price moved up by %.2f%%. Opening long position.", price_change_pct_up)
            if position_open == 'short':
                close_positions(symbol, 'short')
            if open_long_position(symbol, quantity):
                position_open = 'long'
                entry_price = current_price
                lowest_price = current_price
                highest_price = current_price
    elif price_change_pct_down >= threshold_pct:
        if position_open != 'short':
            logger.info("Price moved down by %.2f%%. Opening short position.", price_change_pct_down)
            if position_open == 'long':
                close_positions(symbol, 'long')
            if open_short_position(symbol, quantity):
                position_open = 'short'
                entry_price = current_price
                highest_price = current_price
                lowest_price = current_price

    time.sleep(1)  # 1-second wait

if name == “main”:
symbol = ‘BTCUSD_PERP’ # Set symbol to BTCUSD_PERP
threshold_pct = 0.079
monitor_price(symbol, threshold_pct)

Replaced logger.getLogger(name) with logger.getLogger(name) to ensure it uses the current module’s name

Ensured each function is properly defined and that the main execution block is correctly set up.

Improved the error handling for responses and JSON parsing.

Ensured that delays are handled properly within the logic to prevent frequent and unnecessary API calls, especially after handling errors or while waiting.

script includes traceback.format_exc() in each error logging statement to provide a stack trace that gives more detailed information about where and why an error occurred, helping in debugging and maintaining the code effectively.

1 Like
12

Also same error

import hashlib
import time
import requests
import logging
import hmac
import traceback
from urllib.parse import urlencode

API anahtarları ve sırrı

api_key = ‘’
api_secret = ‘’

Binance API URL’si

base_url = “https://dapi.binance.com” # Coin-M Futures API için base URL

Logging settings

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

def create_signature(params, secret):
# Sort parameters alphabetically and concatenate
query_string = urlencode(sorted(params.items()))
# Create a HMAC-SHA256 signature
return hmac.new(secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()

def get_ohlc_data(symbol, interval=‘1m’, limit=2):
endpoint = ‘/dapi/v1/klines’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘interval’: interval,
‘limit’: limit
}
response = requests.get(url, params=params)
if response.status_code == 200:
try:
return response.json()
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
time.sleep(1)
else:
logger.error(“Failed to retrieve OHLC data: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
time.sleep(1)
return None

def get_position_size(symbol):
endpoint = ‘/dapi/v1/positionRisk’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.get(url, headers=headers, params=params)
if response.status_code == 200:
try:
positions = response.json()
for pos in positions:
if pos[‘symbol’] == symbol:
return float(pos[‘positionAmt’])
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
return 0
else:
logger.error(“Failed to retrieve position data: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
return 0

def open_long_position(symbol, quantity):
endpoint = ‘/dapi/v1/order’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘side’: ‘BUY’,
‘type’: ‘MARKET’,
‘quantity’: quantity,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.post(url, headers=headers, params=params)
if response.status_code == 200:
try:
logger.info(“Long position opened: %s”, response.json())
return True
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
else:
logger.error(“Failed to open long position: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
return False

def open_short_position(symbol, quantity):
endpoint = ‘/dapi/v1/order’
url = f"{base_url}{endpoint}"
params = {
‘symbol’: symbol,
‘side’: ‘SELL’,
‘type’: ‘MARKET’,
‘quantity’: quantity,
‘timestamp’: int(time.time() * 1000)
}
params[‘signature’] = create_signature(params, api_secret)
headers = {‘X-MBX-APIKEY’: api_key}
response = requests.post(url, headers=headers, params=params)
if response.status_code == 200:
try:
logger.info(“Short position opened: %s”, response.json())
return True
except ValueError as e:
logger.error(“JSON parsing error: %s”, e)
logger.error(traceback.format_exc())
else:
logger.error(“Failed to open short position: %d, %s”, response.status_code, response.text)
logger.error(traceback.format_exc())
return False

def close_positions(symbol, position_type):
position_quantity = abs(get_position_size(symbol))
if position_quantity == 0:
logger.info(“No position found to close.”)
return False

side = 'SELL' if position_type == 'long' else 'BUY'
endpoint = '/dapi/v1/order'
url = f"{base_url}{endpoint}"
params = {
    'symbol': symbol,
    'side': side,
    'type': 'MARKET',
    'quantity': position_quantity,
    'timestamp': int(time.time() * 1000)
}
params['signature'] = create_signature(params, api_secret)
headers = {'X-MBX-APIKEY': api_key}
response = requests.post(url, headers=headers, params=params)
if response.status_code == 200:
    try:
        logger.info("Position closed: %s", response.json())
        return True
    except ValueError as e:
        logger.error("JSON parsing error: %s", e)
        logger.error(traceback.format_exc())
else:
    logger.error("Failed to close position: %d, %s", response.status_code, response.text)
    logger.error(traceback.format_exc())
return False

def monitor_price(symbol, threshold_pct):
lowest_price = float(‘inf’)
highest_price = 0
position_open = None
entry_price = None
quantity = 1

logger.info("Bot is running!")
while True:
    ohlc_data = get_ohlc_data(symbol, '1m', 2)
    if ohlc_data is None:
        logger.info("Data retrieval failed, waiting for 30 seconds.")
        time.sleep(30)
        continue

    current_price = float(ohlc_data[-1][4])
    if current_price < lowest_price:
        lowest_price = current_price
    if current_price > highest_price:
        highest_price = current_price

    # Percentage change calculations
    price_change_pct_up = ((current_price - lowest_price) / lowest_price) * 100
    price_change_pct_down = ((current_price - highest_price) / highest_price) * 100

    # Profit/Loss calculation
    if position_open is not None:
        if position_open == 'long':
            profit_loss = (current_price - entry_price) * quantity
        elif position_open == 'short':
            profit_loss = (entry_price - current_price) * quantity
    else:
        profit_loss = 0

    # Remaining percentage and position opening conditions
    if position_open:
        if position_open == 'long':
            remaining_pct = max(threshold_pct - price_change_pct_up, 0)
        elif position_open == 'short':
            remaining_pct = max(threshold_pct - price_change_pct_down, 0)
    else:
        remaining_pct = threshold_pct

    logger.info(f"Current Price: {current_price:.2f} USDT | "
                f"Percentage Change Up: {price_change_pct_up:.2f}% | "
                f"Percentage Change Down: {price_change_pct_down:.2f}% | "
                f"Remaining Percentage: {remaining_pct:.2f}% | "
                f"Profit/Loss: {profit_loss:.2f} USDT")

    if price_change_pct_up >= threshold_pct:
        if position_open != 'long':
            logger.info("Price moved up by %.2f%%. Opening long position.", price_change_pct_up)
            if position_open == 'short':
                close_positions(symbol, 'short')
            if open_long_position(symbol, quantity):
                position_open = 'long'
                entry_price = current_price
                lowest_price = current_price
                highest_price = current_price
    elif price_change_pct_down >= threshold_pct:
        if position_open != 'short':
            logger.info("Price moved down by %.2f%%. Opening short position.", price_change_pct_down)
            if position_open == 'long':
                close_positions(symbol, 'long')
            if open_short_position(symbol, quantity):
                position_open = 'short'
                entry_price = current_price
                highest_price = current_price
                lowest_price = current_price

    time.sleep(1)  # 1-second wait

if name == “main”:
symbol = ‘BTCUSD_PERP’ # Set symbol to BTCUSD_PERP
threshold_pct = 0.079
monitor_price(symbol, threshold_pct)

13

IMG_9670
IMG_96701356×1829 507 KB

14

Correct the issues regarding the API’s “Signature for this request is not valid” error, Integrated the changes throughout all relevant parts.

Modified the entire code to ensure it consistently handles API signatures and requests correctly:

import hashlib
import time
import requests
import logging
import hmac
from urllib.parse import urlencode

Setup logger for better debugging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

api_key = ‘YOUR_API_KEY’ # Replace with your actual API key
api_secret = ‘YOUR_API_SECRET’ # Replace with your actual API secret
base_url = “https://dapi.binance.com”

def create_signature(secret, **params):
“”“Create a query string, sort it alphabetically, and generate a signature.”“”
query_string = urlencode(sorted(params.items()))
signature = hmac.new(secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()
return signature

def api_request(endpoint, method=‘GET’, **params):
“”“General API request function.”“”
headers = {
‘X-MBX-APIKEY’: api_key
}
params[‘timestamp’] = int(time.time() * 1000)
params[‘signature’] = create_signature(api_secret, **params)

if method == 'GET':
    response = requests.get(f"{base_url}{endpoint}", params=params, headers=headers)
else:
    response = requests.post(f"{base_url}{endpoint}", params=params, headers=headers)

try:
    data = response.json()
    if response.status_code == 200:
        return data
    else:
        logger.error("API Error (%s): %s", response.status_code, data)
        return None
except ValueError:
    logger.error("Failed to parse response: %s", response.text)
    return None

def open_long_position(symbol, quantity):
“”“Open a long position.”“”
params = {
‘symbol’: symbol,
‘side’: ‘BUY’,
‘type’: ‘MARKET’,
‘quantity’: quantity
}
response = api_request(‘/dapi/v1/order’, method=‘POST’, **params)
if response:
logger.info(“Long position opened: %s”, response)
else:
logger.error(“Failed to open long position.”)

def monitor_price(symbol, threshold_pct):
“”“Monitoring and handling price changes.”“”
lowest_price = float(‘inf’)
highest_price = 0
position_open = None
entry_price = None
quantity = 1

logger.info("Bot is running!")
while True:
    ohlc_data = api_request('/dapi/v1/klines', symbol=symbol, interval='1m', limit=1)
    if ohlc_data:
        current_price = float(ohlc_data[-1][4])
        if current_price < lowest_price:
            lowest_price = current_price
        if current_price > highest_price:
            highest_price = current_price

        # Calculate percentage changes for decisions
        price_change_pct_up = ((current_price - lowest_price) / lowest_price) * 100
        price_change_pct_down = ((highest_price - current_price) / highest_price) * 100

        # Open or close positions based on price change thresholds
        if price_change_pct_up >= threshold_pct and not position_open:
            open_long_position(symbol, quantity)
            position_open = 'long'
            entry_price = current_price

        elif price_change_pct_down >= threshold_pct and position_open:
            # Close or adjust positions here as necessary
            pass

    else:
        logger.info("Waiting for new data.")
        time.sleep(30)  # Wait before the next API call to avoid hitting rate limits

if name == “main”:
monitor_price(‘BTCUSD_PERP’, 0.079)

You will receive message: INFO:main:Bot is running!

This is working now!!

15

I think it’s not still working
Maybe problem is with my API key

16

IMG_9673
IMG_96732732×2048 513 KB

17

check if your API has authorization to palce trades, and you have inputed your IP address in the box and confirmed it.

18

Additionaly this usually happens due to incorrect ordering of query parameters, missing parameters, or incorrect handling of the API secret in the signature generation process.

Check the below:

The parameters used to generate the signature must be exactly in the order they are sent in the request.

Make sure all required parameters (including timestamp and others that may affect the outcome) are included before generating the signature.

Verify that the query string used for the signature is correctly encoded and concatenated.

Below code has the corrected part of your code with emphasis on the signature generation and API request sending process.

import hashlib
import hmac
import time
import requests
import logging
from urllib.parse import urlencode

Setup logger for better debugging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

api_key = ‘YOUR_API_KEY’
api_secret = ‘YOUR_API_SECRET’
base_url = “https://dapi.binance.com”

def create_signature(secret, **params):
“”“Create a query string, sort it alphabetically, and generate a signature.”“”
query_string = urlencode(sorted(params.items()))
signature = hmac.new(secret.encode(), query_string.encode(), hashlib.sha256).hexdigest()
return signature

def api_request(endpoint, method=‘GET’, **params):
“”“General API request function.”“”
headers = {
‘X-MBX-APIKEY’: api_key
}
params[‘timestamp’] = int(time.time() * 1000)
params[‘signature’] = create_signature(api_secret, **params)

url = f"{base_url}{endpoint}"
if method == 'GET':
    response = requests.get(url, params=params, headers=headers)
else:
    response = requests.post(url, params=params, headers=headers)

try:
    data = response.json()
    if response.status_code == 200:
        return data
    else:
        logger.error("API Error (%s): %s", response.status_code, data)
        return None
except ValueError:
    logger.error("Failed to parse response: %s", response.text)
    return None

def open_long_position(symbol, quantity):
“”“Open a long position.”“”
params = {
‘symbol’: symbol,
‘side’: ‘BUY’,
‘type’: ‘MARKET’,
‘quantity’: quantity
}
response = api_request(‘/dapi/v1/order’, method=‘POST’, **params)
if response:
logger.info(“Long position opened: %s”, response)
else:
logger.error(“Failed to open long position.”)

if name == “main”:
open_long_position(‘BTCUSD_PERP’, 0.001)

The timestamp is always the most recent and included before the signature is generated.

The code ensures the URL parameters are encoded and sorted before being used to generate the signature.

Error handling and logging to capture the full context when the API call fails, including both the status code and error message.

19

No problem with my api key sir.

When i use it with another code it’s working.

20

I still getting same error message sir again and again. I fixed it 100 times. Ending everything is same. Signature error. :tired_face:

21

I will run the full code and get back to you.

22

Basic logic is based on the market price opening or closing positions with 0.379% moving

Opening and closing Threshold

After the Bot Started If the market price moves below 0.379% from the highest point, it will open short. If there are long positions or positions in the open, it will be captured.

After the Bot Started If the market price moves up from the lowest point with a rate of 0.379%, the long opening will open. If there are short positions or positions in the open, it will catch it.

Otherwise, the positions will not be opened or closed

(This means that when long closes, long will open when short is closed. In the form of scissors )

Quantity

The amount of the position that will initially be opened is always 1 contract (in Binance futures

A term used.) will be

If the positions are closed with a loss, the position to be opened against will be 2 times the position of the closed one. Until the taki is closed with snow. After closing with snow, the amount will return to 1 again.

Understanding of profit and loss

It will be calculated according to the opening and closing price of the position

For example

Short

Opening price 100 - closing price 50 = 50. (100-50= 50).

Opening price 100 - closing price 150 = - 50. (100-150 = - 50)

Long

Closing price 50 - Opening price 100 = - 50. (50-100= -50).

Closing price 150 - Opening price 100 = 50 (150-100 = 50)

That’s my strategy