Guías de TRON

Cómo comprar energía TRON con Python (API de TronSave, 2026)

Por TronSave Publicado 7 min de lectura
En esta página

Si tu backend en Python envía USDT (TRC-20) —un bot, un exchange, un servicio de pagos—, te conviene comprar energía TRON con Python de forma automática en lugar de hacerlo a mano. Este es un ejemplo completo y listo para ejecutar con la API de TronSave: consulta tu saldo, crea una orden de energía y consulta su estado hasta que la energía se entrega.

Antes de empezar

  • Obtén una clave API en el panel de TronSave (gasta de tu saldo interno de TronSave, así que nunca la expongas del lado del cliente).
  • Instala el cliente HTTP: pip install requests. ¿Prefieres un wrapper tipado? Usa el SDK oficial: pip install tronsave —consulta la descripción general del SDK.
  • Recarga la cuenta interna. El depósito mínimo es de 10 TRX por transacción, y tu primer depósito necesita aproximadamente 1 TRX adicional para activar la nueva dirección. El saldo se actualiza en unos 3 segundos.

Los endpoints

El script usa cuatro endpoints v2, autenticados con un encabezado apikey:

  • GET /v2/user-info — el saldo de tu cuenta interna.
  • GET /v2/order-book — liquidez y precios disponibles.
  • POST /v2/buy-resource — crea la orden y devuelve un orderId.
  • GET /v2/order/{orderId} — consúltalo hasta que fulfilledPercent llegue a 100.

Todos tienen un límite de 15 solicitudes por segundo. Todos devuelven la misma estructura: error, message y un objeto data. Escribe el parseo una sola vez y funcionará en todas partes.

Ejemplo completo en Python

import time, requests

API_KEY = "your_api_key"
TRONSAVE_API_URL = "https://api.tronsave.io"   # testnet: https://api-dev.tronsave.io
RECEIVER_ADDRESS = "your_receiver_address"
BUY_AMOUNT = 65000          # ~1 USDT (TRC-20) transfer
DURATION = 3600             # rental duration, in seconds (1 hour)
MAX_PRICE_ACCEPTED = 100    # max price in SUN per unit
RESOURCE_TYPE = "ENERGY"    # ENERGY or BANDWIDTH

HEADERS = {"apikey": API_KEY}

def get_account_info():
    return requests.get(f"{TRONSAVE_API_URL}/v2/user-info", headers=HEADERS).json()

def get_order_book():
    return requests.get(f"{TRONSAVE_API_URL}/v2/order-book",
                        headers=HEADERS,
                        params={"address": RECEIVER_ADDRESS}).json()

def buy_resource():
    body = {
        "resourceType": RESOURCE_TYPE,
        "unitPrice": "MEDIUM",          # a price in SUN, or SLOW / MEDIUM / FAST
        "resourceAmount": BUY_AMOUNT,
        "receiver": RECEIVER_ADDRESS,
        "durationSec": DURATION,
        "options": {
            "allowPartialFill": True,
            "maxPriceAccepted": MAX_PRICE_ACCEPTED,
            "preventDuplicateIncompleteOrders": True,
        },
    }
    return requests.post(f"{TRONSAVE_API_URL}/v2/buy-resource",
                         headers={**HEADERS, "Content-Type": "application/json"},
                         json=body).json()

def get_order(order_id):
    return requests.get(f"{TRONSAVE_API_URL}/v2/order/{order_id}", headers=HEADERS).json()

def main():
    print(get_order_book()["data"])      # [{"price": 54, "availableResourceAmount": 2403704}, ...]

    balance = int(get_account_info()["data"]["balance"])
    if balance < MAX_PRICE_ACCEPTED * BUY_AMOUNT:
        raise SystemExit("Insufficient TronSave balance")

    order = buy_resource()
    if order["error"]:
        raise SystemExit(f"Buy failed: {order['message']}")

    order_id = order["data"]["orderId"]
    while True:                          # poll until the energy is delivered
        time.sleep(3)
        detail = get_order(order_id)["data"]
        if detail["fulfilledPercent"] == 100 or detail["remainAmount"] == 0:
            print(f"Energy delivered - paid {detail['payoutAmount'] / 1e6} TRX")
            for d in detail["delegates"]:
                print(d["delegator"], d["amount"], d["txid"])
            break
        print(f"Waiting for fill... {detail['fulfilledPercent']}%")

if __name__ == "__main__":
    main()

Cómo funciona

  1. Primero, lee el mercado. get_order_book() devuelve una lista de niveles {price, availableResourceAmount}, con la oferta más barata primero. Si necesitas 500.000 de energía y los dos niveles más baratos solo suman 300.000, tu precio de ejecución lo fija el tercer nivel. Por eso un maxPriceAccepted bajo y fijo en el código falla sin avisar en los días de mucha demanda.
  2. Verifica el saldo. get_account_info() devuelve balance, depositAddress y representAddress; el saldo viene en SUN y como string, así que conviértelo. 1 TRX = 1.000.000 SUN. Un "50000000" devuelto equivale a 50 TRX.
  3. Crea la orden. buy_resource() envía un POST a /v2/buy-resource. Configura tu API_KEY, tu RECEIVER_ADDRESS y cuánta energía comprar: 65.000 cubren una transferencia de USDT, y unos 130.000 si el destinatario la recibe por primera vez (consulta cuánta energía necesita una transferencia de USDT). Si omites durationSec, su valor predeterminado es 259.200 (3 días). Si todo sale bien, solo recibes un orderId, y eso es lo esperado.
  4. Consulta hasta que se complete. get_order() devuelve la orden en tiempo real: fulfilledPercent (0 = aún pendiente, 1–99 = parcial, 100 = completa), remainAmount, el price real que pagaste en SUN, payoutAmount en SUN y un array delegates con la dirección del proveedor, la cantidad y el txid on-chain de cada coincidencia. Guarda esos txids en tus logs: son tu comprobante, verificable en Tronscan.

Cómo elegir unitPrice

unitPrice acepta un precio entero en SUN o uno de tres niveles, y esos niveles se calculan sobre el libro de órdenes en vivo, no como recargos fijos:

Valor Comportamiento Cuándo usarlo
"SLOW" El precio más bajo al que se puede crear la orden No hay prisa; ahorrar importa más que la velocidad
"MEDIUM" Predeterminado. El precio más bajo que aún obtiene la máxima ejecución del mercado; si el mercado no puede ejecutar nada, MEDIUM = SLOW + 10 Casi siempre
"FAST" Si el mercado está 100% listo, FAST = MEDIUM; por debajo de eso, MEDIUM + 10; con 0% listo, SLOW + 20 La transferencia tiene que salir ya
80 (número) Un precio fijo en SUN, control total Tú mismo fijas el precio a partir del libro de órdenes

Cómo manejar los errores que realmente ocurren

Las respuestas que no son 2xx llegan con error: true y un código incluido en message, como TSAS:106 API_KEY_REQUIRED. Toma decisiones según el código, no según el texto: la redacción puede cambiar. Estos son los que un bot en Python encuentra en producción:

  • INTERNAL_BALANCE_ACCOUNT_TOO_LOW — recarga la cuenta interna. Vale la pena configurar una alerta antes de que pase, no después.
  • PRICE_EXCEED_MAX_PRICE_REQUIRED — el mercado subió por encima de tu maxPriceAccepted. Vuelve a leer el libro de órdenes y reintenta con un tope más alto, o espera.
  • CANNOT_FULFILLED — configuraste onlyCreateWhenFulfilled: true y el mercado no puede ejecutar el 100% en este momento. Quita esa opción o activa allowPartialFill.
  • MUST_BE_WAIT_PREVIOUS_ORDER_FILLED — enviaste parámetros idénticos mientras una orden anterior seguía abierta. Es preventDuplicateIncompleteOrders: true haciendo su trabajo: es la opción que evita que un bucle de reintentos compre dos veces.
  • 429 RATE_LIMIT — aplica backoff exponencial (1 s, 2 s, 4 s) y mantente por debajo de 15 solicitudes por segundo.

Los errores de esquema se ven distintos: vienen de la capa HTTP como FST_ERR_VALIDATION e indican el campo que falta, por ejemplo "body must have required property 'receiver'". Son útiles durante el desarrollo y señal de un bug, no de una condición del mercado.

Testnet vs. mainnet

Desarrolla contra la testnet con https://api-dev.tronsave.io (Nile, sin TRX reales) y luego cambia a https://api.tronsave.io para producción. Solo cambia el dominio: todas las rutas son idénticas, así que basta con cambiar una única constante TRONSAVE_API_URL.

Obtén una clave de Nile en testnet.tronsave.io con una billetera configurada en la red Nile y luego recárgala desde el faucet de Nile. Algo que debes tener en cuenta: las claves API, los saldos y las órdenes están completamente separados entre los dos entornos. Una clave de mainnet devuelve INVALID_API_KEY contra el host de testnet, lo cual es el comportamiento correcto, pero confunde a las 2 de la mañana. TronSave no es compatible con Shasta: usa Nile.

¿Trabajas en otro lenguaje? El mismo flujo está disponible como SDK para Node.js, Rust, Java y PHP, y hay una guía general de automatización con la API. Si prefieres no ejecutar ningún bucle de consulta, Auto-Buy recarga una dirección vigilada según el umbral que definas. La referencia completa está en la documentación de TronSave.

Preguntas frecuentes

¿Necesito TronWeb?
No para el flujo con clave API de arriba: basta con requests. TronWeb solo hace falta si firmas y pagas directamente con una clave privada, que es el flujo de transacción firmada.

¿Cuánta energía necesita cada transferencia de USDT?
Unos 65.000 (≈130.000 hacia una billetera que nunca ha tenido USDT).

¿De dónde sale el pago?
De tu saldo prepago de TronSave, que recargas en el panel. No se firma nada on-chain por cada orden, por eso el script no necesita clave privada.

¿Qué pasa si la orden solo se completa parcialmente?
Con allowPartialFill: true recibes lo que el mercado pudo emparejar, fulfilledPercent queda entre 1 y 99 y solo pagas la parte emparejada. Haz un bucle sobre remainAmount y crea una orden adicional por la diferencia, o configura onlyCreateWhenFulfilled: true para que la orden nunca se cree a menos que pueda completarse.

TronSave
TronSave

El equipo de TronSave desarrolla el mercado de energía y ancho de banda de TRON en tronsave.io y escribe estas guías a partir de pruebas reales en la red principal de TRON.

Artículos relacionados

Usamos Google Analytics para saber qué guías ayudan a los lectores. Solo instala cookies si permites la analítica. El blog no muestra anuncios. Privacidad