---
title: Cómo comprar energía TRON con Python (API de TronSave, 2026)
description: "Compra energía TRON con Python y la API de TronSave: ejemplo completo y ejecutable para ver tu saldo, crear una orden y esperar la entrega."
url: https://blog.tronsave.io/es/comprar-energia-tron-python-api/
canonical: https://blog.tronsave.io/es/comprar-energia-tron-python-api/
lang: es-ES
datePublished: 2026-11-15T11:22:03+00:00
dateModified: 2026-11-15T11:22:03+00:00
author: TronSave
publisher: TronSave (https://tronsave.io/)
categories:
  - Guías de TRON
keywords: comprar energía tron python, energía tron api python
translations:
  en: https://blog.tronsave.io/how-to-buy-tron-energy-in-python/
  ru: https://blog.tronsave.io/ru/kak-kupit-energiyu-tron-na-python/
  pt: https://blog.tronsave.io/pt/comprar-energia-tron-com-python/
  zh: https://blog.tronsave.io/zh/python-goumai-bochang-nengliang/
  de: https://blog.tronsave.io/de/tron-energie-mit-python-kaufen/
---

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

Si tu backend en Python envía USDT (TRC-20) —un bot, un exchange, un servicio de pagos—, te conviene **comprar [energía TRON](https://blog.tronsave.io/es/energia-y-ancho-de-banda-tron-guia/) 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](https://tronsave.io/es/market) (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](https://blog.tronsave.io/buy-tron-energy-with-code-tronsave-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](https://blog.tronsave.io/es/cuanta-energia-necesita-una-transferencia-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](https://blog.tronsave.io/buy-tron-energy-with-code-tronsave-sdk/), y hay una [guía general de automatización con la API](https://blog.tronsave.io/es/automatizar-compra-energia-tron-api/). Si prefieres no ejecutar ningún bucle de consulta, [Auto-Buy](https://blog.tronsave.io/es/tronsave-auto-buy-compra-automatica-energia-tron/) recarga una dirección vigilada según el umbral que definas. La referencia completa está en la [documentación de TronSave](https://docs.tronsave.io).

## 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](https://tronsave.io/es/market). 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.

**Empieza a construir:** consigue una clave API en el [mercado de TronSave](https://tronsave.io/es/market) y lee la [documentación para desarrolladores](https://docs.tronsave.io).
