---
title: "TRON-Energie in PHP kaufen: das TronSave SDK (2026)"
description: "TRON-Energie in PHP kaufen mit dem offiziellen TronSave SDK: Composer-Installation, typisierte Modelle, Retries und Rate Limits, Kauf in vier Aufrufen."
url: https://blog.tronsave.io/de/tron-energie-mit-php-kaufen/
canonical: https://blog.tronsave.io/de/tron-energie-mit-php-kaufen/
lang: de-DE
datePublished: 2026-11-18T16:37:28+00:00
dateModified: 2026-11-18T16:37:28+00:00
author: TronSave
publisher: TronSave (https://tronsave.io/)
categories:
  - TRON-Ratgeber
keywords: TRON-Energie in PHP kaufen, TRON-Energie mit PHP kaufen
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/
  es: https://blog.tronsave.io/es/comprar-energia-tron-con-php/
  pt: https://blog.tronsave.io/pt/comprar-energia-tron-com-php/
  zh: https://blog.tronsave.io/zh/php-goumai-bochang-nengliang/
---

# TRON-Energie in PHP kaufen: das TronSave SDK (2026)

Am schnellsten **kaufen Sie TRON-Energie in PHP** mit dem offiziellen TronSave SDK: `composer require tronsave/sdk`, einen Client mit Ihrem API-Key erzeugen, die Kosten schätzen, die Order platzieren und sie bis 100 % abfragen. Vier typisierte Aufrufe, kein rohes HTTP, keine selbstgebaute Retry-Schleife. Dieser Leitfaden deckt die gesamte Integration ab – Installation, Standardwerte, Fehlerbehandlung und wie die Order tatsächlich bezahlt wird.

## Warum ein PHP-Backend das braucht

PHP betreibt einen enormen Teil des Händler-Webs – WooCommerce-Shops, Laravel-Zahlungsdienste, eigene Abrechnungspanels. Sobald einer davon **USDT (TRC-20)** auf TRON auszahlt oder annimmt, gilt dieselbe Rechnung wie für alle anderen: Jede Überweisung verbraucht Energie, und fehlende Energie wird bezahlt, indem TRX zu Protokollpreisen verbrannt wird. So verbrennt eine einzige Stablecoin-Auszahlung etwa 6,43 TRX bzw. etwa 13,03 TRX an einen Empfänger, der noch nie USDT hatte (Stand: November 2026).

Die Energie direkt vor einem Auszahlungslauf zu mieten, kostet in der Regel nur einen Bruchteil des Verbrennens. Passiert das im Code, füllt sich der Dienst selbst auf – niemand muss um 3 Uhr nachts ein Dashboard beobachten, kein Batch bleibt hängen, weil eine Wallet leer ist. Wenn Sie zuerst die Sicht auf Endpoint-Ebene möchten, lesen Sie unseren [Leitfaden zur API-Automatisierung](https://blog.tronsave.io/de/tron-energie-per-api-kaufen/); dieser Beitrag beschreibt denselben Ablauf mit PHP-Typen statt roher Requests.

![Der Energiemarkt, auf dem ein PHP-Backend über das TronSave SDK TRON-Energie kauft](https://blog.tronsave.io/wp-content/uploads/2025/09/Energy-rental-interface-on-Tronsave-copy.png)

Das SDK platziert Orders auf demselben Energiemarkt wie die Weboberfläche. Quelle: TronSave

## Was ist das TronSave PHP SDK?

Es ist der offizielle PHP-Client für die TronSave v2 API, auf Packagist als `tronsave/sdk` veröffentlicht (Version 2.0.0, MIT-Lizenz, **PHP 8.1+**). Daneben gibt es offizielle SDKs für TypeScript, Python, Java und Rust – alle kapseln dieselben Endpoints mit demselben Verhalten, und das wird durch eine gemeinsame sprachübergreifende Konformitäts-Testsuite geprüft, nicht von Hand.

Der PHP-Client ist klein, aber für den Produktionsbetrieb gebaut:

-   **Typisierte Ergebnisse.** Antworten kommen als readonly-Klassen zurück – `UserInfo`, `EstimateBuyResource`, `Order`, `OrderBookLevel` – und nicht als assoziative Arrays, durch die Sie sich durchraten müssen.
-   **Echte Enums.** `ResourceType`, `PriceTier`, `OrderType`, `OrderStatus` und `Network` sind Backed Enums aus PHP 8.1 – ein Tippfehler ist also ein Fatal Error an der Aufrufstelle statt eines 400 vom Server.
-   **PSR-18-Transport.** Standardmäßig Guzzle, aber Sie können jeden PSR-18-Client injizieren – praktisch, wenn Ihr Framework bereits einen konfigurierten, instrumentierten HTTP-Stack hat.
-   **Retries und Rate Limiting eingebaut.** Beides ist standardmäßig aktiv und wird unten beschrieben.

## Installieren und konfigurieren

```
composer require tronsave/sdk
```

Dann erzeugen Sie einen Client. Jedes Konstruktor-Argument ist optional und benannt, Sie setzen also nur, was Sie brauchen:

```
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` bringt seine eigene Basis-URL mit, Sie hardcoden also nie einen Hostnamen: `Network::Testnet` zeigt auf die Nile-Test-API und `Network::Mainnet` auf die Produktion. Entwickeln Sie im Testnet, wo nichts echte TRX kostet, und stellen Sie dann den Enum um.

Derselbe Enum stellt auch `fundAddress()` bereit – die Adresse, an der Ihr Prepaid-Guthaben aufgeladen wird. Sie aus dem Enum zu lesen statt einen String in Ihre Konfiguration zu kopieren, ist die sicherere Gewohnheit: Eine Einzahlungsadresse aus einer Chatnachricht oder einem Suchergebnis ist ein klassischer Weg, eine Aufladung zu verlieren.

## Energie kaufen, von Anfang bis Ende

Vier Aufrufe. Der erste ist optional, lohnt sich aber für einen 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
}
```

Zwei Details in diesem Snippet zahlen sich aus. **`estimateBuyResource` ist nicht authentifiziert** – Sie können einen Kauf bepreisen, bevor Sie einen Key haben, und ein Preisaufruf in einem Hot Path verbraucht nie Ihr Rate-Limit-Budget für die Authentifizierung. Und das zweite Argument von `buyResource` ist das Options-Array: `allowPartialFill` lässt die Order von mehreren Anbietern füllen, statt auf einen großen zu warten, und `maxPriceAccepted` ist Ihre Obergrenze in SUN pro Einheit – genau die Linie zwischen einer robusten Integration und einer, die bei einer Preisspitze zu viel zahlt.

Die Order ist nicht erledigt, wenn `buyResource` zurückkehrt – zurück kommt eine `orderId`. Die Delegierung folgt einige Sekunden später. Fragen Sie `getOrder` ab, bis `fulfilledPercent` 100 erreicht, bevor Sie die Überweisung senden, die die Energie braucht.

## Standardwerte und Limits, die Sie kennen sollten

| Verhalten | Wert |
| --- | --- |
| Standard-Ressourcentyp | `ENERGY` |
| Standard-Preisstufe | `MEDIUM` (auch `FAST`, `SLOW` oder ein fester SUN-Preis) |
| Standarddauer | `259200` Sekunden – 3 Tage |
| Mindestmenge für Energie-Orders | Muss **größer als 64.000** sein |
| Clientseitiges Rate Limit | 15 Requests/Sekunde; 1/Sekunde für `getExtendableDelegates` |
| Standard-Timeout / Retries | 30.000 ms / 3 Retries |
| Format von `extendTo` | Unix-Zeitstempel in **Sekunden** |

Das Minimum von 64.000 wird *clientseitig* durchgesetzt: Eine zu kleine Order wirft eine Exception, bevor ein HTTP-Request gesendet wird, sodass eine fehlerhafte Schleife ihr Rate Limit nicht damit verbraucht, immer wieder dieselbe Ablehnung zu erhalten. Auch der Rate Limiter arbeitet clientseitig – er taktet Ihre eigenen Aufrufe, statt den Server mit 429 antworten zu lassen.

## Fehlerbehandlung, die den Produktionsbetrieb übersteht

Jeder Fehler ist eine typisierte Exception, die von `Tronsave\TronsaveException` erbt und `->code`, `->status` und `->raw` enthält:

| Exception | Wann | Was tun |
| --- | --- | --- |
| `TronsaveAuthException` | 401 | Key korrigieren. Nie wiederholen. |
| `TronsaveValidationException` | 400, falsche Parameter | Aufruf korrigieren. Nie wiederholen. |
| `TronsaveBusinessException` | 400, inhaltlich abgelehnt | `->code` lesen und verzweigen. |
| `TronsaveRateLimitException` | 429 | `->retryAfterMs` lang warten. |
| `TronsaveNetworkException` | Transportfehler | Kann gefahrlos wiederholt werden. |

```
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]);
}
```

Die Aufteilung ist wichtig, weil sie Ihnen ohne Raten sagt, was wiederholbar ist. Das SDK wiederholt die vorübergehenden Fälle bereits selbst – 408, 425, 429, 500, 502, 503 und 504 – mit exponentiellem Backoff und Jitter und beachtet einen `Retry-After`\-Header, wenn der Server einen sendet. Was in Ihrem `catch`\-Block ankommt, wurde also bereits wiederholt; die Exceptions oben sind genau die, über die Ihr Code wirklich entscheiden muss.

## Wie die Order bezahlt wird

Es gibt zwei Zahlungswege, und das SDK wählt anhand dessen, was Sie übergeben:

-   **Prepaid-Guthaben (empfohlen für Server).** Rufen Sie `buyResource` ohne `signedTx` auf, dann authentifiziert sich die Order mit Ihrem API-Key und wird über Ihr TronSave-Guthaben abgerechnet. Ihr privater TRON-Schlüssel kommt mit der Integration nie in Berührung – genau das wollen Sie auf einem Webserver.
-   **On-Chain pro Order.** Übergeben Sie eine selbst erstellte und signierte `signedTx`, dann wird die Order stattdessen über diese Transaktion bezahlt.

Der Client bietet außerdem `getSignedTransaction()`, das serverseitig signiert. Der eigene Docblock empfiehlt, lokal zu signieren, und daran sollten Sie sich halten: Dieser Aufruf schickt einen privaten Schlüssel über das Netz. Für ein PHP-Backend ist der Weg über das Prepaid-Guthaben einfacher und sicherer – nutzen Sie ihn.

## Verlängern statt neu kaufen

Wenn eine bestehende Delegierung bald abläuft, ist Verlängern günstiger als eine neue Order. Rufen Sie `getExtendableDelegates()` mit einem Empfänger und einem `extendTo`\-Unix-Zeitstempel auf; Sie erhalten `isAbleToExtend`, `totalEstimateTrx` und eine `extendData`\-Payload, die Sie direkt an `extendRequest()` übergeben. Beachten Sie das strengere Limit von 1 pro Sekunde für den ersten Aufruf – es ist der einzige Endpoint, den das SDK stärker drosselt als die übrigen.

Unser [Leitfaden zur Extend-Funktion](https://blog.tronsave.io/de/extend-funktion-tron-energie-verlaengern-aufstocken/) erklärt, wann Verlängern besser ist als ein Neukauf.

## FAQ

### Welche PHP-Version brauche ich?

PHP 8.1 oder neuer. Das SDK nutzt Backed Enums, readonly-Properties und benannte Argumente, die alle mit 8.0 und 8.1 eingeführt wurden.

### Brauche ich Guzzle?

Guzzle ist der Standard, es funktioniert also sofort. Der Transport basiert aber auf PSR-18, Sie können also jeden kompatiblen Client injizieren – praktisch, wenn Ihre Anwendung schon einen mit eigenem Logging, Proxy oder Timeout-Regeln konfiguriert hat.

### Kann ich testen, ohne echte TRX auszugeben?

Ja. Erzeugen Sie den Client mit `Network::Testnet`, dann sind Sie im Nile-Testnetz mit einem separaten API-Host. Dort kostet nichts echtes Geld. Um live zu gehen, ändern Sie nur diesen einen Enum-Wert.

### Wie viel Energie sollte ich für eine USDT-Überweisung kaufen?

Etwa 65.000 für einen Empfänger, der bereits USDT hält, und etwa 130.000 für einen, der noch nie welche hatte – siehe [wie viel Energie eine USDT-Überweisung braucht](https://blog.tronsave.io/de/wie-viel-trx-um-usdt-zu-senden/). Denken Sie daran: Das Order-Minimum ist *größer als* 64.000, 65.000 ist also die kleinste praktikable Energie-Order.

### Hinkt das PHP SDK dem TypeScript SDK hinterher?

Nein. Alle fünf Clients zielen auf dieselbe v2 API in derselben Version und müssen eine gemeinsame Konformitäts-Testsuite bestehen, sodass das Verhalten zwischen den Sprachen nicht auseinanderläuft. Wenn Sie mehrere Sprachen nutzen, beschreiben die SDK-Leitfäden für [TypeScript](https://blog.tronsave.io/de/tron-energie-per-code-kaufen-tronsave-sdk/), [Java](https://blog.tronsave.io/de/tron-energie-mit-java-kaufen/) und [Rust](https://blog.tronsave.io/de/tron-energie-mit-rust-kaufen/) denselben Ablauf.

### Was passiert, wenn eine Order nur teilweise gefüllt wird?

Mit aktiviertem `allowPartialFill` erhalten Sie, was der Markt liefern konnte, und `fulfilledPercent` zeigt an, wie viel. Prüfen Sie den Wert, bevor Sie die Transaktion senden, die von der Energie abhängt – eine teilweise gefüllte Order deckt Ihre Überweisung womöglich nicht ab.

## Fazit

Wenn Ihr PHP-Dienst USDT auf TRON bewegt, ist Energie ein laufender Kostenfaktor, den Sie um bis zu 80 % senken können, und das SDK macht daraus eine Integration mit vier Aufrufen statt eines Projekts. Installieren Sie es, bepreisen Sie die Order ohne Key, kaufen Sie über Ihr Prepaid-Guthaben, damit kein privater Schlüssel Ihren Webserver berührt, und fragen Sie bis 100 % ab, bevor Sie senden.

**Jetzt integrieren:** Führen Sie `composer require tronsave/sdk` aus, holen Sie sich einen Key im [TronSave-Dashboard](https://tronsave.io/de) und bepreisen Sie Ihre erste Order auf dem [Live-Energiemarkt](https://tronsave.io/de/market).

*Das TronSave SDK wird von TronSave veröffentlicht, dem Herausgeber dieses Blogs. Die hier beschriebenen Paketversionen, Standardwerte und Limits entsprechen v2.0.0 und können sich in späteren Releases ändern – prüfen Sie die offizielle SDK-Dokumentation, bevor Sie eine Version festlegen. Dies ist keine Finanzberatung.*
