---
title: Cómo comprar energía TRON en PHP con el SDK de TronSave (2026)
description: "Compra energía TRON en PHP con el SDK oficial de TronSave: Composer, modelos tipados, reintentos y rate limit integrados y compra en 4 llamadas."
url: https://blog.tronsave.io/es/comprar-energia-tron-con-php/
canonical: https://blog.tronsave.io/es/comprar-energia-tron-con-php/
lang: es-ES
datePublished: 2026-11-18T16:37:30+00:00
dateModified: 2026-11-18T16:37:30+00:00
author: TronSave
publisher: TronSave (https://tronsave.io/)
categories:
  - Guías de TRON
keywords: comprar energía TRON en PHP
translations:
  en: https://blog.tronsave.io/how-to-buy-tron-energy-in-php-sdk-guide/
  ru: https://blog.tronsave.io/ru/kak-kupit-energiyu-tron-na-php/
  pt: https://blog.tronsave.io/pt/comprar-energia-tron-com-php/
  zh: https://blog.tronsave.io/zh/php-goumai-bochang-nengliang/
  de: https://blog.tronsave.io/de/tron-energie-mit-php-kaufen/
---

# Cómo comprar energía TRON en PHP con el SDK de TronSave (2026)

La forma más rápida de **comprar energía TRON en PHP** es el SDK oficial de TronSave: `composer require tronsave/sdk`, crea un cliente con tu API key, estima el costo, coloca la orden y consúltala hasta llegar al 100%. Cuatro llamadas tipadas, sin HTTP a mano y sin bucles de reintento caseros. Esta guía cubre toda la integración: instalación, valores por defecto, manejo de errores y cómo se paga realmente la orden.

## Por qué un backend PHP necesita esto

PHP mueve una parte enorme de la web de comercios: tiendas WooCommerce, servicios de pago en Laravel, paneles de facturación a medida. En cuanto uno de ellos empieza a pagar o aceptar **USDT (TRC-20)** en TRON, se topa con la misma aritmética que todos: cada transferencia consume energía, y la energía que no tienes se paga quemando TRX a tarifa del protocolo. Así es como un solo pago en stablecoin termina quemando unos 6,43 TRX, o unos 13,03 TRX si el destinatario nunca tuvo USDT (a noviembre de 2026).

Alquilar la energía justo antes de una tanda de pagos suele costar una fracción de lo que cuesta quemarla. Hacerlo desde el código significa que el servicio se recarga solo: nadie vigilando un panel a las 3 de la mañana, ningún lote detenido porque una billetera se quedó sin saldo. Si primero quieres la vista a nivel de endpoints, lee nuestra [guía de automatización con la API](https://blog.tronsave.io/es/automatizar-compra-energia-tron-api/); este artículo es el mismo flujo con tipos de PHP en lugar de peticiones crudas.

![El mercado de energía en el que un backend PHP compra energía TRON mediante el SDK de TronSave](https://blog.tronsave.io/wp-content/uploads/2025/09/Energy-rental-interface-on-Tronsave-copy.png)

El SDK coloca las órdenes en el mismo mercado de energía que usa la interfaz web. Fuente: TronSave

## ¿Qué es el SDK de TronSave para PHP?

Es el cliente oficial de PHP para la API v2 de TronSave, publicado en Packagist como `tronsave/sdk` (versión 2.0.0, licencia MIT, **PHP 8.1+**). Convive con los SDK oficiales para TypeScript, Python, Java y Rust: todos envuelven los mismos endpoints con el mismo comportamiento, verificado por una suite de conformidad compartida entre lenguajes y no a mano.

El cliente de PHP es pequeño, pero está pensado para producción:

-   **Resultados tipados.** Las respuestas llegan como clases readonly —`UserInfo`, `EstimateBuyResource`, `Order`, `OrderBookLevel`— y no como arrays asociativos que tienes que adivinar.
-   **Enums de verdad.** `ResourceType`, `PriceTier`, `OrderType`, `OrderStatus` y `Network` son backed enums de PHP 8.1, así que un error de tipeo es un fatal error en el punto de llamada y no un 400 del servidor.
-   **Transporte PSR-18.** Guzzle por defecto, pero puedes inyectar cualquier cliente PSR-18; útil si tu framework ya tiene una pila HTTP configurada e instrumentada.
-   **Reintentos y rate limiting integrados.** Ambos vienen activados por defecto y se describen más abajo.

## Instalación y configuración

```
composer require tronsave/sdk
```

Luego crea un cliente. Todos los argumentos del constructor son opcionales y con nombre, así que solo defines lo que necesitas:

```
use Tronsave\TronsaveClient;
use Tronsave\Network;

$sdk = new TronsaveClient(
    apiKey: getenv('TRONSAVE_API_KEY'),
    network: Network::Testnet,   // Network::Mainnet to go live
    timeoutMs: 30000,            // default
    maxRetries: 3,               // default
);
```

`Network` lleva su propia URL base, así que nunca escribes un hostname a mano: `Network::Testnet` apunta a la API de prueba Nile y `Network::Mainnet` a producción. Desarrolla en la testnet, donde nada cuesta TRX reales, y luego cambia el enum.

El mismo enum expone también `fundAddress()`, la dirección donde se recarga tu saldo prepago. Leerla del enum en vez de pegar un string en tu configuración es el hábito más seguro: una dirección de depósito copiada de un mensaje de chat o de un resultado de búsqueda es una forma clásica de perder una recarga.

## Comprar energía de principio a fin

Cuatro llamadas. La primera es opcional, pero vale la pena incluirla en un health check.

```
use Tronsave\TronsaveClient;
use Tronsave\Network;

$sdk = new TronsaveClient(apiKey: getenv('TRONSAVE_API_KEY'), network: Network::Mainnet);

// 1. Who am I, and can I afford this run?
$me = $sdk->getUserInfo();
// $me->id, $me->balance, $me->representAddress, $me->depositAddress

// 2. What will it cost? (no API key required for this call)
$est = $sdk->estimateBuyResource([
    'receiver'       => 'TFwUFWr3QV376677Z8VWXxGUAMFSrq1MbM',
    'resourceType'   => 'ENERGY',
    'resourceAmount' => 65000,
    'durationSec'    => 3600,
]);
// $est->estimateTrx, $est->unitPrice, $est->durationSec, $est->availableResource

// 3. Place the order.
$order = $sdk->buyResource(
    ['receiver' => 'TFwUFWr3QV376677Z8VWXxGUAMFSrq1MbM', 'resourceAmount' => 65000, 'durationSec' => 3600],
    ['allowPartialFill' => true, 'maxPriceAccepted' => 100],
);

// 4. Poll until the energy is actually delegated.
$status = $sdk->getOrder($order->orderId);
echo $status->fulfilledPercent;   // 100 = fully delegated
echo $status->remainAmount;       // 0 when nothing is left to fill
foreach ($status->delegates as $d) {
    // $d->delegator, $d->amount, $d->txid
}
```

Dos detalles de ese fragmento valen oro. **`estimateBuyResource` no requiere autenticación**: puedes cotizar una compra antes de tener una key, y una llamada de precio en una ruta crítica nunca gasta tu cupo de rate limit en autenticación. Y el segundo argumento de `buyResource` es el array de opciones: `allowPartialFill` permite que la orden se llene con varios proveedores en lugar de esperar a uno grande, y `maxPriceAccepted` es tu tope en SUN por unidad, que marca la diferencia entre una integración resiliente y una que paga de más durante un pico de precios.

La orden no está lista cuando `buyResource` responde: lo que devuelve es un `orderId`. La delegación llega unos segundos después. Consulta `getOrder` hasta que `fulfilledPercent` llegue a 100 antes de transmitir la transferencia que necesita la energía.

## Valores por defecto y límites que conviene conocer

| Comportamiento | Valor |
| --- | --- |
| Tipo de recurso por defecto | `ENERGY` |
| Nivel de precio por defecto | `MEDIUM` (también `FAST`, `SLOW` o un precio en SUN) |
| Duración por defecto | `259200` segundos: 3 días |
| Orden mínima de energía | Debe ser **mayor que 64.000** |
| Rate limit del lado del cliente | 15 solicitudes/segundo; 1/segundo para `getExtendableDelegates` |
| Timeout / reintentos por defecto | 30.000 ms / 3 reintentos |
| Formato de `extendTo` | Timestamp Unix en **segundos** |

El mínimo de 64.000 se aplica *del lado del cliente*: una orden demasiado pequeña lanza una excepción antes de hacer cualquier petición HTTP, así que un bucle mal escrito no puede gastar su rate limit descubriendo el mismo rechazo una y otra vez. El rate limiter también funciona del lado del cliente: regula tus propias llamadas en lugar de dejar que el servidor te devuelva un 429.

## Manejo de errores que aguanta producción

Cada fallo es una excepción tipada que extiende `Tronsave\TronsaveException` y trae `->code`, `->status` y `->raw`:

| Excepción | Cuándo | Qué hacer |
| --- | --- | --- |
| `TronsaveAuthException` | 401 | Corrige la key. Nunca reintentes. |
| `TronsaveValidationException` | 400, parámetros incorrectos | Corrige la llamada. Nunca reintentes. |
| `TronsaveBusinessException` | 400, rechazada por el fondo | Lee `->code` y ramifica. |
| `TronsaveRateLimitException` | 429 | Espera `->retryAfterMs`. |
| `TronsaveNetworkException` | Fallo de transporte | Se puede reintentar sin riesgo. |

```
use Tronsave\{TronsaveBusinessException, TronsaveRateLimitException};

try {
    $order = $sdk->buyResource(['receiver' => $addr, 'resourceAmount' => 65000]);
} catch (TronsaveRateLimitException $e) {
    usleep($e->retryAfterMs * 1000);
} catch (TronsaveBusinessException $e) {
    $log->warning('order rejected', ['code' => $e->code, 'raw' => $e->raw]);
}
```

La separación importa porque te dice qué se puede reintentar sin adivinar. El SDK ya reintenta por ti los casos transitorios —408, 425, 429, 500, 502, 503 y 504— con backoff exponencial y jitter, respetando la cabecera `Retry-After` cuando el servidor la envía. Lo que llega a tu bloque `catch` ya se reintentó, así que las excepciones de arriba son las que tu código realmente tiene que decidir.

## Cómo se paga la orden

Hay dos formas de pago, y el SDK elige según lo que le pases:

-   **Saldo prepago (recomendado para servidores).** Llama a `buyResource` sin `signedTx` y la orden se autentica con tu API key y se liquida contra tu saldo de TronSave. Tu clave privada de TRON nunca toca la integración, que es justo lo que quieres en un servidor web.
-   **On-chain por orden.** Pasa un `signedTx` que hayas construido y firmado tú mismo, y la orden se paga con esa transacción.

El cliente también expone `getSignedTransaction()`, que firma del lado del servidor. Su propio docblock recomienda firmar localmente, y conviene hacerle caso: esa llamada envía una clave privada por la red. Para un backend PHP, el saldo prepago es más simple y más seguro: úsalo.

## Extender en lugar de volver a comprar

Si una delegación que ya tienes está por vencer, extenderla sale más barato que comprar una orden nueva. Llama a `getExtendableDelegates()` con un receptor y un timestamp Unix `extendTo`; devuelve `isAbleToExtend`, `totalEstimateTrx` y un payload `extendData` que pasas directamente a `extendRequest()`. Ojo con el límite más estricto de 1 por segundo en esa primera llamada: es el único endpoint que el SDK regula más que el resto.

Nuestra [guía de la función Extend](https://blog.tronsave.io/es/funcion-extend-ampliar-recargar-energia-tron/) explica cuándo extender conviene más que volver a comprar.

## Preguntas frecuentes (FAQ)

### ¿Qué versión de PHP necesito?

PHP 8.1 o superior. El SDK usa backed enums, propiedades readonly y argumentos con nombre, que llegaron con PHP 8.0 y 8.1.

### ¿Necesito Guzzle?

Es el valor por defecto, así que funciona sin configurar nada. Pero el transporte es PSR-18, así que puedes inyectar cualquier cliente compatible; práctico si tu aplicación ya tiene uno configurado con su propio logging, proxy o política de timeouts.

### ¿Puedo probar sin gastar TRX reales?

Sí. Crea el cliente con `Network::Testnet` y estarás en la red de prueba Nile, con un host de API separado. Ahí nada cuesta dinero real. Cambia ese único valor del enum para pasar a producción.

### ¿Cuánta energía debo comprar para una transferencia de USDT?

Unas 65.000 para un destinatario que ya tiene USDT y unas 130.000 para uno que nunca tuvo; consulta [cuánta energía necesita una transferencia de USDT](https://blog.tronsave.io/es/cuantos-trx-se-necesitan-para-enviar-usdt/). Recuerda que el mínimo de la orden es *mayor que* 64.000, así que 65.000 es la orden de energía más pequeña en la práctica.

### ¿El SDK de PHP va por detrás del de TypeScript?

No. Los cinco clientes apuntan a la misma API v2 en la misma versión y deben pasar una suite de conformidad compartida, así que el comportamiento no se desvía entre lenguajes. Si trabajas con varios lenguajes, las guías del SDK para [TypeScript](https://blog.tronsave.io/es/comprar-energia-tron-con-codigo-sdk-tronsave/), [Java](https://blog.tronsave.io/es/comprar-energia-tron-con-java/) y [Rust](https://blog.tronsave.io/es/comprar-energia-tron-con-rust/) describen el mismo flujo.

### ¿Qué pasa si una orden se llena solo parcialmente?

Con `allowPartialFill` activado recibes lo que el mercado pudo ofrecer, y `fulfilledPercent` indica cuánto. Revísalo antes de transmitir la transacción que depende de la energía: una orden llenada parcialmente puede no cubrir tu transferencia.

## En resumen

Si tu servicio PHP mueve USDT en TRON, la energía es un costo recurrente que puedes reducir hasta 80%, y el SDK lo convierte en una integración de cuatro llamadas en lugar de un proyecto. Instálalo, cotiza la orden sin key, compra con tu saldo prepago para que ninguna clave privada toque tu servidor web, y consulta hasta el 100% antes de enviar.

**Empieza a integrar:** ejecuta `composer require tronsave/sdk`, obtén una key en el [panel de TronSave](https://tronsave.io/es) y cotiza tu primera orden en [el mercado de energía en vivo](https://tronsave.io/es/market).

*El SDK de TronSave lo publica TronSave, editor de este blog. Las versiones del paquete, los valores por defecto y los límites descritos aquí corresponden a v2.0.0 y pueden cambiar en versiones posteriores: revisa la documentación oficial del SDK antes de fijar una versión. Esto no es asesoramiento financiero.*
