Apidog

Platform Pengembangan API Kolaboratif All-in-one

Desain API

Dokumentasi API

Debug API

Mocking API

Pengujian Otomatis API

Daftar gratis
UnduhUntuk Mac atau Linux
Home

/

Sudut Pandang

/

Cara Menggunakan Binance API dengan Python

Cara Menggunakan Binance API dengan Python

Tutorial ini memandu Anda menggunakan Binance API, dari pengaturan autentikasi hingga membuat berbagai jenis permintaan.

Ardianto Nugroho

Ardianto Nugroho

Updated on April 15, 2025

Pengantar Binance API

Binance API menyediakan pengembang dengan akses terprogram ke platform perdagangan Binance, memungkinkan mereka untuk membangun bot perdagangan, aplikasi, dan alat yang berinteraksi dengan bursa. Tutorial ini akan memandu Anda melalui proses penggunaan Binance API, mulai dari menyiapkan autentikasi hingga membuat berbagai jenis permintaan.

Meskipun banyak pengembang secara tradisional mengandalkan Postman untuk pengujian API, Apidog menawarkan pengalaman yang lebih efisien dan khusus untuk bekerja dengan API mata uang kripto seperti Binance. Dengan antarmuka yang intuitif, penanganan autentikasi yang ditingkatkan, dan fitur khusus kripto bawaan, Apidog secara signifikan mengurangi waktu pengaturan yang diperlukan untuk mulai menguji dan menerapkan titik akhir Binance API.

button

Alat kolaborasi waktu nyata platform dan kemampuan pembuatan dokumentasi yang komprehensif membuatnya sangat berharga bagi tim yang mengerjakan aplikasi perdagangan kripto.

Jika Anda serius tentang integrasi Binance API yang efisien, beralih ke Apidog akan secara nyata meningkatkan alur kerja pengembangan Anda dan mengurangi waktu penerapan untuk proyek kripto Anda.

button

Menyiapkan Autentikasi Binance API

Sebelum menggunakan Binance API, Anda perlu membuat kunci API dari akun Binance Anda. Bagian ini membahas cara menyiapkan dan mengamankan kunci API Anda.

Membuat Kunci API Binance

  1. Masuk ke akun Binance Anda
  2. Navigasi ke "Manajemen API" di pengaturan akun Anda
  3. Buat kunci API baru
  4. Catat kunci API dan kunci rahasia Anda
  5. Konfigurasikan batasan (daftar putih IP, izin perdagangan, dll.)

Jenis Kunci API yang Didukung oleh Binance API

Binance mendukung tiga jenis metode autentikasi kunci API:

  1. Kunci HMAC - Metode autentikasi yang paling umum
  2. Kunci RSA - Menawarkan fitur keamanan yang ditingkatkan
  3. Kunci Ed25519 - Memberikan kinerja dan keamanan terbaik

Contoh Autentikasi HMAC

Berikut cara melakukan autentikasi dengan kunci HMAC:

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

# API credentials
api_key = 'your_api_key'
api_secret = 'your_api_secret'

# Base URL for Binance API
base_url = '<https://api.binance.com>'

# Function to create a signature for authenticated endpoints
def get_signature(query_string):
    return hmac.new(
        api_secret.encode('utf-8'),
        query_string.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

# Example request to get account information
def get_account():
    endpoint = '/api/v3/account'
    timestamp = int(time.time() * 1000)

    params = {
        'timestamp': timestamp,
        'recvWindow': 5000  # Optional parameter
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

# Call the function
account_info = get_account()
print(account_info)

Memahami Titik Akhir Binance API

Binance API diatur ke dalam beberapa kategori titik akhir berdasarkan fungsinya.

Titik Akhir Binance API Umum

Titik akhir ini memberikan informasi umum tentang bursa:

# Test connectivity
def test_connectivity():
    endpoint = '/api/v3/ping'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

# Get server time
def get_server_time():
    endpoint = '/api/v3/time'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

# Get exchange information
def get_exchange_info():
    endpoint = '/api/v3/exchangeInfo'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

Titik Akhir Binance API Data Pasar

Titik akhir ini menyediakan akses ke data pasar:

# Get order book for a symbol
def get_order_book(symbol, limit=100):
    endpoint = '/api/v3/depth'
    params = {
        'symbol': symbol,
        'limit': limit
    }
    url = f"{base_url}{endpoint}?{urlencode(params)}"
    response = requests.get(url)
    return response.json()

# Get recent trades
def get_recent_trades(symbol, limit=500):
    endpoint = '/api/v3/trades'
    params = {
        'symbol': symbol,
        'limit': limit
    }
    url = f"{base_url}{endpoint}?{urlencode(params)}"
    response = requests.get(url)
    return response.json()

# Get candlestick data
def get_klines(symbol, interval, start_time=None, end_time=None, limit=500):
    endpoint = '/api/v3/klines'
    params = {
        'symbol': symbol,
        'interval': interval,
        'limit': limit
    }

    if start_time:
        params['startTime'] = start_time
    if end_time:
        params['endTime'] = end_time

    url = f"{base_url}{endpoint}?{urlencode(params)}"
    response = requests.get(url)

    # Format the response
    klines = response.json()
    formatted_klines = []
    for k in klines:
        formatted_klines.append({
            'open_time': k[0],
            'open': float(k[1]),
            'high': float(k[2]),
            'low': float(k[3]),
            'close': float(k[4]),
            'volume': float(k[5]),
            'close_time': k[6],
            'quote_volume': float(k[7]),
            'trades': k[8],
            'taker_buy_base_volume': float(k[9]),
            'taker_buy_quote_volume': float(k[10])
        })

    return formatted_klines

Berdagang dengan Binance API

Titik akhir perdagangan memungkinkan Anda untuk menempatkan dan mengelola pesanan.

Menempatkan Pesanan dengan Binance API

Berikut cara menempatkan berbagai jenis pesanan:

# Place a LIMIT order
def place_limit_order(symbol, side, quantity, price):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,  # 'BUY' or 'SELL'
        'type': 'LIMIT',
        'timeInForce': 'GTC',  # Good Till Canceled
        'quantity': quantity,
        'price': price,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

# Place a MARKET order
def place_market_order(symbol, side, quantity):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,  # 'BUY' or 'SELL'
        'type': 'MARKET',
        'quantity': quantity,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

# Place a STOP_LOSS order
def place_stop_loss_order(symbol, side, quantity, stop_price):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,
        'type': 'STOP_LOSS',
        'quantity': quantity,
        'stopPrice': stop_price,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

Mengelola Pesanan dengan Binance API

Berikut cara menanyakan, membatalkan, dan melacak pesanan:

# Query order status
def query_order(symbol, order_id=None, orig_client_order_id=None):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    if order_id:
        params['orderId'] = order_id
    elif orig_client_order_id:
        params['origClientOrderId'] = orig_client_order_id
    else:
        raise ValueError("Either order_id or orig_client_order_id must be provided")

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

# Cancel an order
def cancel_order(symbol, order_id=None, orig_client_order_id=None):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    if order_id:
        params['orderId'] = order_id
    elif orig_client_order_id:
        params['origClientOrderId'] = orig_client_order_id
    else:
        raise ValueError("Either order_id or orig_client_order_id must be provided")

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.delete(url, headers=headers)
    return response.json()

# Get all open orders
def get_open_orders(symbol=None):
    endpoint = '/api/v3/openOrders'
    timestamp = int(time.time() * 1000)

    params = {
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    if symbol:
        params['symbol'] = symbol

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

Data Akun dan Pengguna dengan Binance API

Titik akhir ini memungkinkan Anda untuk mengakses informasi akun dan mengalirkan data pengguna.

Informasi Akun dengan Binance API

# Get account information
def get_account_information():
    endpoint = '/api/v3/account'
    timestamp = int(time.time() * 1000)

    params = {
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

# Get account trade list
def get_account_trades(symbol, start_time=None, end_time=None, limit=500):
    endpoint = '/api/v3/myTrades'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'timestamp': timestamp,
        'limit': limit,
        'recvWindow': 5000
    }

    if start_time:
        params['startTime'] = start_time
    if end_time:
        params['endTime'] = end_time

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

Aliran Data Pengguna dengan Binance API

# Start a user data stream
def start_user_data_stream():
    endpoint = '/api/v3/userDataStream'

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(f"{base_url}{endpoint}", headers=headers)
    return response.json()

# Keep alive a user data stream
def keep_alive_user_data_stream(listen_key):
    endpoint = '/api/v3/userDataStream'

    params = {
        'listenKey': listen_key
    }

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.put(f"{base_url}{endpoint}?{urlencode(params)}", headers=headers)
    return response.json()

# Close a user data stream
def close_user_data_stream(listen_key):
    endpoint = '/api/v3/userDataStream'

    params = {
        'listenKey': listen_key
    }

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.delete(f"{base_url}{endpoint}?{urlencode(params)}", headers=headers)
    return response.json()

Fitur Lanjutan Binance API

Bagian ini membahas beberapa fitur yang lebih canggih dari Binance API.

Bekerja dengan Daftar Pesanan (OCO) di Binance API

Pesanan One-Cancels-the-Other (OCO) memungkinkan Anda untuk menempatkan sepasang pesanan di mana jika salah satunya dipicu, yang lain secara otomatis dibatalkan:

# Place an OCO order
def place_oco_order(symbol, side, quantity, price, stop_price):
    endpoint = '/api/v3/orderList/oco'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,
        'quantity': quantity,
        'price': price,
        'stopPrice': stop_price,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    # Define the types for the OCO order based on side
    if side == 'SELL':
        params['aboveType'] = 'STOP_LOSS'
        params['belowType'] = 'LIMIT_MAKER'
    else:
        params['aboveType'] = 'LIMIT_MAKER'
        params['belowType'] = 'STOP_LOSS'

    params['aboveTimeInForce'] = 'GTC'
    params['belowTimeInForce'] = 'GTC'

    query_string = urlencode(params)
    signature = get_signature(query_string)

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

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

Menangani Batas Tarif di Binance API

Binance menerapkan batas tarif untuk permintaan API. Berikut cara menanganinya:

import time
from functools import wraps

# Decorator to handle rate limits
def handle_rate_limit(max_retries=3, retry_delay=30):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            while retries <= max_retries:
                try:
                    response = func(*args, **kwargs)
                    if 'code' in response and response['code'] == -1429:  # Rate limit exceeded
                        retries += 1
                        if retries > max_retries:
                            raise Exception(f"Rate limit exceeded after {max_retries} retries")
                        print(f"Rate limit exceeded. Waiting {retry_delay} seconds before retry...")
                        time.sleep(retry_delay)
                    else:
                        return response
                except Exception as e:
                    if "429" in str(e) or "418" in str(e):
                        retries += 1
                        if retries > max_retries:
                            raise
                        print(f"Rate limit exceeded. Waiting {retry_delay} seconds before retry...")
                        time.sleep(retry_delay)
                    else:
                        raise
        return wrapper
    return decorator

# Example usage
@handle_rate_limit()
def get_exchange_info_with_retry():
    endpoint = '/api/v3/exchangeInfo'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

Membangun Bot Perdagangan Binance API Lengkap

Sekarang mari kita satukan semuanya untuk membangun bot perdagangan sederhana:

import hmac
import hashlib
import time
import requests
import json
import websocket
import threading
from urllib.parse import urlencode

class BinanceTrader:
    def __init__(self, api_key, api_secret, symbol='BTCUSDT'):
        self.api_key = api_key
        self.api_secret = api_secret
        self.base_url = '<https://api.binance.com>'
        self.symbol = symbol
        self.ws = None
        self.listen_key = None
        self.keep_alive_thread = None

    def get_signature(self, query_string):
        return hmac.new(
            self.api_secret.encode('utf-8'),
            query_string.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()

    def get_server_time(self):
        endpoint = '/api/v3/time'
        response = requests.get(f"{self.base_url}{endpoint}")
        return response.json()['serverTime']

    def get_account_info(self):
        endpoint = '/api/v3/account'
        timestamp = int(time.time() * 1000)

        params = {
            'timestamp': timestamp,
            'recvWindow': 5000
        }

        query_string = urlencode(params)
        signature = self.get_signature(query_string)

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

        headers = {
            'X-MBX-APIKEY': self.api_key
        }

        response = requests.get(url, headers=headers)
        return response.json()

    def place_market_order(self, side, quantity):
        endpoint = '/api/v3/order'
        timestamp = int(time.time() * 1000)

        params = {
            'symbol': self.symbol,
            'side': side,
            'type': 'MARKET',
            'quantity': quantity,
            'timestamp': timestamp,
            'recvWindow': 5000
        }

        query_string = urlencode(params)
        signature = self.get_signature(query_string)

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

        headers = {
            'X-MBX-APIKEY': self.api_key
        }

        response = requests.post(url, headers=headers)
        return response.json()

    def start_user_data_stream(self):
        endpoint = '/api/v3/userDataStream'

        headers = {
            'X-MBX-APIKEY': self.api_key
        }

        response = requests.post(f"{self.base_url}{endpoint}", headers=headers)
        self.listen_key = response.json()['listenKey']
        return self.listen_key

    def keep_alive_user_data_stream(self):
        while True:
            if self.listen_key:
                endpoint = '/api/v3/userDataStream'

                params = {
                    'listenKey': self.listen_key
                }

                headers = {
                    'X-MBX-APIKEY': self.api_key
                }

                requests.put(f"{self.base_url}{endpoint}?{urlencode(params)}", headers=headers)
            time.sleep(30 * 60)  # Keep alive every 30 minutes

    def on_message(self, ws, message):
        data = json.loads(message)

        # Handle account updates
        if data.get('e') == 'outboundAccountPosition':
            print("Account update received:")
            print(f"Update time: {data['u']}")
            print("Balances:")
            for balance in data['B']:
                print(f"Asset: {balance['a']}, Free: {balance['f']}, Locked: {balance['l']}")

        # Handle order updates
        elif data.get('e') == 'executionReport':
            print("Order update received:")
            print(f"Symbol: {data['s']}")
            print(f"Side: {data['S']}")
            print(f"Order type: {data['o']}")
            print(f"Order status: {data['X']}")
            print(f"Price: {data['p']}")
            print(f"Quantity: {data['q']}")
            print(f"Executed quantity: {data['z']}")

            # Implement trading logic here based on order updates
            if data['X'] == 'FILLED' and data['S'] == 'BUY':
                # Example: Place a sell order when buy is filled
                sell_price = float(data['p']) * 1.05  # 5% profit target
                self.place_limit_order('SELL', data['q'], sell_price)

    def on_error(self, ws, error):
        print(f"Error: {error}")

    def on_close(self, ws, close_status_code, close_msg):
        print("WebSocket connection closed")

    def on_open(self, ws):
        print("WebSocket connection opened")

    def start_websocket(self):
        self.start_user_data_stream()
        socket_url = f"wss://stream.binance.com:9443/ws/{self.listen_key}"

        self.ws = websocket.WebSocketApp(
            socket_url,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close,
            on_open=self.on_open
        )

        # Start keep-alive thread
        self.keep_alive_thread = threading.Thread(target=self.keep_alive_user_data_stream)
        self.keep_alive_thread.daemon = True
        self.keep_alive_thread.start()

        # Run the WebSocket in a separate thread
        ws_thread = threading.Thread(target=self.ws.run_forever)
        ws_thread.daemon = True
        ws_thread.start()

        return ws_thread

# Example usage
if __name__ == "__main__":
    api_key = "your_api_key"
    api_secret = "your_api_secret"

    trader = BinanceTrader(api_key, api_secret, 'BTCUSDT')

    # Get account information
    account_info = trader.get_account_info()
    print("Account Information:")
    print(f"Can Trade: {account_info['canTrade']}")
    print(f"Can Withdraw: {account_info['canWithdraw']}")
    print(f"Can Deposit: {account_info['canDeposit']}")

    # Print balances
    print("\\\\nBalances:")
    for balance in account_info['balances']:
        if float(balance['free']) > 0 or float(balance['locked']) > 0:
            print(f"Asset: {balance['asset']}, Free: {balance['free']}, Locked: {balance['locked']}")

    # Start the WebSocket for real-time updates
    ws_thread = trader.start_websocket()

    try:
        # Keep the main thread running
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("Stopping...")
        trader.ws.close()

Praktik Terbaik untuk Menggunakan Binance API

Berikut adalah beberapa praktik terbaik yang harus diikuti saat bekerja dengan Binance API:

Praktik Keamanan untuk Binance API

  1. Batasi Izin Kunci API: Hanya aktifkan izin yang Anda butuhkan (misalnya, hanya baca, perdagangan, penarikan)
  2. Daftar Putih Alamat IP: Batasi kunci API Anda agar hanya berfungsi dari alamat IP tertentu
  3. Amankan Penyimpanan Kunci API: Jangan pernah menyandikan kunci API secara permanen dalam kode Anda, gunakan variabel lingkungan atau brankas aman
  4. Rotasi Kunci Reguler: Ubah kunci API Anda secara berkala untuk mengurangi risiko
import os

# Load API keys from environment variables
api_key = os.environ.get('BINANCE_API_KEY')
api_secret = os.environ.get('BINANCE_API_SECRET')

if not api_key or not api_secret:
    raise ValueError("API keys not found in environment variables")

Penanganan Kesalahan dengan Binance API

Terapkan penanganan kesalahan yang kuat untuk menangani kesalahan API dan masalah koneksi:

def safe_request(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            response = func(*args, **kwargs)
            # Check for API error codes
            if isinstance(response, dict) and 'code' in response:
                print(f"API Error: Code {response['code']}, Message: {response.get('msg', 'No message')}")
                # Handle specific error codes
                if response['code'] == -1021:  # INVALID_TIMESTAMP
                    print("Server and local time are not synchronized. Adjusting timestamp...")
                    # Implement timestamp adjustment logic here
                elif response['code'] == -2010:  # INSUFFICIENT_BALANCE
                    print("Insufficient balance for order.")
                # Add more specific error handling as needed
            return response
        except requests.exceptions.RequestException as e:
            print(f"Request Error: {e}")
            # Implement retry logic or fallback behavior
            return None
        except json.JSONDecodeError:
            print("Failed to decode JSON response")
            return None
        except Exception as e:
            print(f"Unexpected error: {e}")
            return None
    return wrapper

@safe_request
def get_account_info_safe():
    # Implementation of get_account_info with proper error handling
    # ...

Kesimpulan

Binance API menawarkan cara yang ampuh untuk berinteraksi dengan bursa Binance secara terprogram. Tutorial ini mencakup aspek penting penggunaan API, mulai dari autentikasi hingga menempatkan pesanan dan mengelola akun Anda. Dengan mengikuti praktik terbaik dan menerapkan penanganan kesalahan yang tepat, Anda dapat membangun aplikasi dan bot perdagangan yang kuat yang memanfaatkan serangkaian fitur ekstensif Binance.

Ingatlah untuk menjaga keamanan kunci API Anda, menghormati batas tarif, dan menguji kode Anda secara menyeluruh di lingkungan pengujian sebelum menggunakannya dengan dana sungguhan. Saat Binance memperbarui API mereka, pastikan untuk tetap mendapatkan informasi tentang setiap perubahan pada titik akhir atau parameter untuk memastikan aplikasi Anda terus berfungsi dengan benar.

Dengan pengetahuan yang diperoleh dari tutorial ini, Anda akan diperlengkapi dengan baik untuk mulai membangun alat dan aplikasi perdagangan Anda sendiri menggunakan Binance API.

button
Di Mana Mengunduh Postman Bahasa Indonesia Gratis?Sudut Pandang

Di Mana Mengunduh Postman Bahasa Indonesia Gratis?

Bisakah Anda mengunduh Postman Bahasa Indonesia gratis? Meskipun Postman tidak memiliki dukungan Bahasa Indonesia native, ada solusi lain. Jelajahi ini & temukan Apidog, alternatif Postman terpadu yang kuat untuk menyederhanakan alur kerja API Anda, apa pun bahasanya.

Oliver Kingsley

April 22, 2025

Cara Menggunakan GPT-4.1 dengan CursorSudut Pandang

Cara Menggunakan GPT-4.1 dengan Cursor

Panduan ini membahas tolok ukur, harga, & 2 cara integrasi GPT-4.1 ke Cursor.

Ardianto Nugroho

April 15, 2025

Cara Menggunakan GPT-4.1 API Gratis, Tanpa Batas dengan Windsurf (Untuk Saat Ini)Sudut Pandang

Cara Menggunakan GPT-4.1 API Gratis, Tanpa Batas dengan Windsurf (Untuk Saat Ini)

Artikel ini membahas kemampuan GPT-4.1, harga, dan panduan detail cara menggunakan model AI canggih ini gratis dengan platform Windsurf.

Ardianto Nugroho

April 15, 2025