---
title: TRON-Energie mit Python kaufen (TronSave API, 2026)
description: "TRON-Energie mit Python über die TronSave API kaufen – lauffähiges Beispiel: Guthaben prüfen, Energie-Order aufgeben und Status bis zur Lieferung abfragen."
url: https://blog.tronsave.io/de/tron-energie-mit-python-kaufen/
canonical: https://blog.tronsave.io/de/tron-energie-mit-python-kaufen/
lang: de-DE
datePublished: 2026-11-15T11:22:01+00:00
dateModified: 2026-11-15T11:22:01+00:00
author: TronSave
publisher: TronSave (https://tronsave.io/)
categories:
  - TRON-Ratgeber
keywords: tron energie python kaufen,tron energie 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/
  es: https://blog.tronsave.io/es/comprar-energia-tron-python-api/
  pt: https://blog.tronsave.io/pt/comprar-energia-tron-com-python/
  zh: https://blog.tronsave.io/zh/python-goumai-bochang-nengliang/
---

# TRON-Energie mit Python kaufen (TronSave API, 2026)

Wenn Ihr Python-Backend USDT (TRC-20) versendet – ein Bot, eine Börse, ein Zahlungsdienst –, sollten Sie **[TRON-Energie](https://blog.tronsave.io/de/tron-energie-und-bandbreite/) mit Python kaufen**, und zwar automatisch statt von Hand. Dies ist ein vollständiges, lauffähiges Beispiel mit der TronSave API: Es prüft Ihr Guthaben, gibt eine Energie-Order auf und fragt den Status ab, bis die Energie geliefert ist.

## Bevor Sie beginnen

-   Holen Sie sich einen **API-Key** im [TronSave-Dashboard](https://tronsave.io/de/market) (er belastet Ihr internes TronSave-Guthaben – geben Sie ihn niemals clientseitig preis).
-   Installieren Sie den HTTP-Client: `pip install requests`. Sie bevorzugen einen typisierten Wrapper? Dann nutzen Sie stattdessen das offizielle SDK: `pip install tronsave` – siehe die [SDK-Übersicht](https://blog.tronsave.io/buy-tron-energy-with-code-tronsave-sdk/).
-   Laden Sie das interne Konto auf. Die Mindesteinzahlung beträgt **10 TRX** pro Transaktion, und für Ihre erste Einzahlung benötigen Sie etwa **1 zusätzlichen TRX**, um die neue Adresse zu aktivieren. Das Guthaben wird nach etwa 3 Sekunden aktualisiert.

## Die Endpunkte

Das Skript nutzt vier v2-Endpunkte, authentifiziert über einen `apikey`\-Header:

-   `GET /v2/user-info` – das Guthaben Ihres internen Kontos.
-   `GET /v2/order-book` – verfügbare Liquidität und Preise.
-   `POST /v2/buy-resource` – gibt die Order auf und liefert eine `orderId` zurück.
-   `GET /v2/order/{orderId}` – abfragen, bis `fulfilledPercent` 100 erreicht.

Jeder dieser Endpunkte ist auf **15 Anfragen pro Sekunde** begrenzt. Alle liefern dieselbe Hülle zurück: `error`, `message` und ein `data`\-Objekt. Schreiben Sie die Auswertung einmal, und sie funktioniert überall.

## Vollständiges Python-Beispiel

```
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()
```

## So funktioniert es

1.  **Zuerst den Markt lesen.** `get_order_book()` liefert eine Liste von `{price, availableResourceAmount}`\-Stufen – das günstigste Angebot zuerst. Wenn Sie 500.000 Energie benötigen und die beiden günstigsten Stufen zusammen nur 300.000 bereithalten, bestimmt die dritte Stufe Ihren Ausführungspreis. Deshalb scheitert ein fest kodierter, niedriger `maxPriceAccepted` an geschäftigen Tagen stillschweigend.
2.  **Das Guthaben prüfen.** `get_account_info()` liefert `balance`, `depositAddress` und `representAddress` – alle Beträge in **SUN** und als String, also wandeln Sie sie um. 1 TRX = 1.000.000 SUN. Ein zurückgegebener Wert `"50000000"` entspricht 50 TRX.
3.  **Die Order aufgeben.** `buy_resource()` sendet einen POST an `/v2/buy-resource`. Legen Sie Ihren `API_KEY`, die `RECEIVER_ADDRESS` und die zu kaufende Energiemenge fest – **65.000** decken eine USDT-Überweisung ab, etwa **130.000** bei einem Empfänger, der zum ersten Mal USDT erhält (siehe [wie viel Energie eine USDT-Überweisung benötigt](https://blog.tronsave.io/de/wie-viel-energie-usdt-ueberweisung/)). `durationSec` ist standardmäßig 259.200 (3 Tage), wenn Sie den Wert weglassen. Bei Erfolg erhalten Sie nur eine `orderId` zurück – das ist so vorgesehen.
4.  **Die Ausführung abfragen.** `get_order()` liefert die aktuelle Order: `fulfilledPercent` (0 = noch ausstehend, 1–99 = teilweise, 100 = vollständig), `remainAmount`, den tatsächlich gezahlten `price` in SUN, `payoutAmount` in SUN sowie ein `delegates`\-Array mit Anbieteradresse, Menge und On-Chain-`txid` für jeden Match. Protokollieren Sie diese txids – sie sind Ihr Beleg und auf Tronscan überprüfbar.

## unitPrice richtig wählen

`unitPrice` akzeptiert entweder einen ganzzahligen Preis in SUN oder eine von drei Stufen, und diese Stufen werden anhand des aktuellen Orderbuchs bestimmt, nicht als feste Aufschläge:

| Wert | Verhalten | Einsatz, wenn |
| --- | --- | --- |
| `"SLOW"` | Der niedrigste Preis, zu dem die Order aufgegeben werden kann | Es ist nicht zeitkritisch, Sparen ist wichtiger als Geschwindigkeit |
| `"MEDIUM"` | Standard. Niedrigster Preis, der noch die maximale Ausführung am Markt erreicht; kann der Markt gar nicht ausführen, gilt MEDIUM = SLOW + 10 | Fast immer |
| `"FAST"` | Ist der Markt zu 100 % bereit, gilt FAST = MEDIUM; darunter MEDIUM + 10; bei 0 % Bereitschaft SLOW + 20 | Die Überweisung muss sofort raus |
| `80` (Zahl) | Ein fester Preis in SUN, volle Kontrolle | Sie berechnen den Preis selbst anhand des Orderbuchs |

## Die Fehler, die in der Praxis tatsächlich auftreten

Antworten außerhalb von 2xx kommen mit `error: true` und einem in `message` eingebetteten Code zurück, etwa `TSAS:106 API_KEY_REQUIRED`. Verzweigen Sie anhand des Codes, nicht anhand des Klartexts – die Formulierung kann sich ändern. Diese Fehler trifft ein Python-Bot im Produktivbetrieb:

-   `INTERNAL_BALANCE_ACCOUNT_TOO_LOW` – laden Sie das interne Konto auf. Es lohnt sich, einen Alarm auszulösen, bevor es passiert, nicht erst danach.
-   `PRICE_EXCEED_MAX_PRICE_REQUIRED` – der Markt ist über Ihren `maxPriceAccepted` gestiegen. Lesen Sie das Orderbuch erneut und versuchen Sie es mit einer höheren Obergrenze, oder warten Sie ab.
-   `CANNOT_FULFILLED` – Sie haben `onlyCreateWhenFulfilled: true` gesetzt, und der Markt kann die Order gerade nicht zu 100 % ausführen. Entfernen Sie dieses Flag oder aktivieren Sie `allowPartialFill`.
-   `MUST_BE_WAIT_PREVIOUS_ORDER_FILLED` – Sie haben identische Parameter gesendet, während eine frühere Order noch offen ist. Hier erfüllt `preventDuplicateIncompleteOrders: true` seinen Zweck; diese Option verhindert, dass eine Retry-Schleife doppelt kauft.
-   `429 RATE_LIMIT` – warten Sie mit exponentiellem Backoff (1 s, 2 s, 4 s) und bleiben Sie unter 15 Anfragen pro Sekunde.

Schemafehler sehen anders aus: Sie stammen aus der HTTP-Schicht als `FST_ERR_VALIDATION` und nennen das fehlende Feld, z. B. `"body must have required property 'receiver'"`. Das ist während der Entwicklung nützlich und deutet auf einen Bug hin, nicht auf eine Marktlage.

## Testnet vs. Mainnet

Entwickeln Sie im Testnet mit `https://api-dev.tronsave.io` (Nile, kein echtes TRX) und wechseln Sie für den Produktivbetrieb zu `https://api.tronsave.io`. Nur die Domain ändert sich – alle Pfade bleiben identisch, Sie müssen also lediglich eine einzige `TRONSAVE_API_URL`\-Konstante umstellen.

Einen Nile-Key erhalten Sie unter `testnet.tronsave.io` mit einer Wallet, die auf das Nile-Netzwerk eingestellt ist; anschließend laden Sie sie über das Nile-Faucet auf. Eines sollten Sie einplanen: **API-Keys, Guthaben und Orders sind in beiden Umgebungen vollständig getrennt**. Ein Mainnet-Key liefert gegenüber dem Testnet-Host `INVALID_API_KEY` zurück – das ist korrekt, um 2 Uhr nachts aber verwirrend. TronSave unterstützt Shasta nicht – verwenden Sie Nile.

Sie arbeiten mit einer anderen Sprache? Derselbe Ablauf ist als SDK für [Node.js, Rust, Java und PHP](https://blog.tronsave.io/buy-tron-energy-with-code-tronsave-sdk/) verfügbar, und es gibt einen allgemeinen [Leitfaden zur API-Automatisierung](https://blog.tronsave.io/de/tron-energie-per-api-kaufen/). Wenn Sie lieber gar keine Polling-Schleife betreiben möchten, füllt [Auto-Buy](https://blog.tronsave.io/de/tronsave-auto-buy-tron-energie-automatisch/) eine überwachte Adresse ab einem von Ihnen festgelegten Schwellenwert auf. Die vollständige Referenz finden Sie in der [TronSave-Dokumentation](https://docs.tronsave.io).

## FAQ

**Brauche ich TronWeb?**  
Nicht für den oben gezeigten Ablauf mit API-Key – einfaches `requests` genügt. TronWeb benötigen Sie nur, wenn Sie direkt mit einem Private Key signieren und bezahlen, also beim Ablauf mit signierten Transaktionen.

**Wie viel Energie braucht eine USDT-Überweisung?**  
Etwa 65.000 (≈130.000 an eine Wallet, die noch nie USDT gehalten hat).

**Woher kommt die Zahlung?**  
Aus Ihrem vorausbezahlten TronSave-Guthaben, das Sie im [Dashboard](https://tronsave.io/de/market) aufladen. Pro Order wird nichts On-Chain signiert, deshalb benötigt das Skript keinen Private Key.

**Was passiert, wenn die Order nur teilweise ausgeführt wird?**  
Mit `allowPartialFill: true` erhalten Sie die Menge, die der Markt zuordnen konnte, `fulfilledPercent` liegt zwischen 1 und 99, und Sie zahlen nur für den zugeordneten Teil. Prüfen Sie in einer Schleife `remainAmount` und geben Sie für die Differenz eine Folge-Order auf, oder setzen Sie `onlyCreateWhenFulfilled: true`, damit die Order nur erstellt wird, wenn sie vollständig ausgeführt werden kann.

**Jetzt umsetzen:** Holen Sie sich einen API-Key auf dem [TronSave-Markt](https://tronsave.io/de/market) und lesen Sie die [Entwicklerdokumentation](https://docs.tronsave.io).
