POST /apiv2/time/order

Compre ciclos específicos de delegación de energía para una dirección TRON en Modo Host.

Resumen

El punto final de Orden de Tiempo le permite comprar un número específico de ciclos de delegación de energía para una dirección que ya está en Modo Host. Cada ciclo proporciona 131.000 unidades de energía durante 24 horas. Este punto final es ideal para un control preciso de la asignación de energía y la gestión del presupuesto, permitiéndole comprar exactamente el número de ciclos necesarios para sus operaciones.

URL del Punto Final

POST https://netts.io/apiv2/time/order

Autenticación

Este punto final utiliza autenticación mediante cuerpo JSON (no encabezados). Su clave API, la dirección de destino y el recuento de ciclos deseado se proporcionan en el cuerpo de la solicitud.

Flujo de Autenticación

1. API Key Validation: System verifies the API key exists and is active
2. IP Whitelist Check: Request IP must match configured whitelist
3. Ownership Verification: API key must own the specified address
4. Balance Check: Account must have sufficient balance for the cycles
5. Status Verification: Address must be in Host Mode and not in infinity mode

Encabezados de la Petición

Header	Required	Description
Content-Type	Yes	application/json

Cuerpo de la solicitud

{
    "api_key": "your_api_key",
    "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
    "cycles": 10
}

Parámetros

Parameter	Type	Required	Validation	Description
api_key	string	Yes	Must exist in system	Your API key for authentication and billing
address	string	Yes	TRC-20 format	TRON address to purchase cycles for (must start with 'T' and be 34 characters)
cycles	integer	Yes	1-1000	Number of 24-hour energy cycles to purchase

Validación de Parámetros

• api_key:

  • Must be a valid 32-character hexadecimal string
  • Must be associated with an active account
  • Must have ownership of the specified address
  • Account must not be suspended or restricted
  • Balance must cover cycle cost

• address:

  • Must match TRC-20 format ^T[1-9A-HJ-NP-Za-km-z]{33}$
  • Must be currently in Host Mode under your account
  • Cannot be in infinity mode (use standard mode only)
  • Cannot have pending cycle orders
  • Must have completed initial activation

• cycles:

  • Must be a positive integer between 1 and 1000
  • Total cycles (existing + new) cannot exceed 10,000
  • Minimum order: 1 cycle
  • Maximum single order: 1000 cycles
  • Bulk orders >1000 require special approval

• IP Address:

  • Your request IP must be in the whitelist associated with your API key
  • Maximum 5 IP addresses per API key
  • IPv4 and IPv6 supported

Ejemplos de Solicitudes

cURL

curl -X POST https://netts.io/apiv2/time/order \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_API_KEY_HERE",
    "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
    "cycles": 10
  }'

Python

import requests
import json
from typing import Dict, Optional

def order_cycles(api_key: str, address: str, cycles: int) -> Dict:
    """
    Purchase energy delegation cycles for a TRON address in Host Mode.
    
    Args:
        api_key: Your API authentication key
        address: TRON address to purchase cycles for
        cycles: Number of cycles to purchase (1-1000)
        
    Returns:
        API response dictionary
    """
    url = "https://netts.io/apiv2/time/order"
    
    # Validate address format
    if not address.startswith('T') or len(address) != 34:
        raise ValueError(f"Invalid TRON address format: {address}")
    
    # Validate cycle count
    if not 1 <= cycles <= 1000:
        raise ValueError(f"Invalid cycle count: {cycles}. Must be between 1 and 1000")
    
    data = {
        "api_key": api_key,
        "address": address,
        "cycles": cycles
    }
    
    try:
        response = requests.post(url, json=data, verify=True, timeout=30)
        response.raise_for_status()
        
        result = response.json()
        
        if result['code'] == 0:
            print(f"✅ Successfully purchased {result['data']['cycles_purchased']} cycles")
            print(f"Address: {result['data']['address']}")
            print(f"Total cycles: {result['data']['total_cycles']}")
            print(f"Total cost: {result['data']['total_cost']} TRX")
            print(f"Next delegation: {result['data'].get('next_delegation_time', 'N/A')}")
        else:
            print(f"❌ Error: {result['msg']}")
            
        return result
        
    except requests.exceptions.RequestException as e:
        print(f"❌ Request failed: {str(e)}")
        raise
    except json.JSONDecodeError as e:
        print(f"❌ Invalid JSON response: {str(e)}")
        raise

# Example usage
if __name__ == "__main__":
    API_KEY = "YOUR_API_KEY_HERE"
    ADDRESS = "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE"
    CYCLES = 10
    
    result = order_cycles(API_KEY, ADDRESS, CYCLES)

Node.js

const axios = require('axios');

/**
 * Purchase energy delegation cycles for a TRON address in Host Mode
 * @param {string} apiKey - Your API authentication key
 * @param {string} address - TRON address to purchase cycles for
 * @param {number} cycles - Number of cycles to purchase (1-1000)
 * @returns {Promise<Object>} API response
 */
async function orderCycles(apiKey, address, cycles) {
    const url = 'https://netts.io/apiv2/time/order';
    
    // Validate address format
    if (!address.startsWith('T') || address.length !== 34) {
        throw new Error(`Invalid TRON address format: ${address}`);
    }
    
    // Validate cycle count
    if (!Number.isInteger(cycles) || cycles < 1 || cycles > 1000) {
        throw new Error(`Invalid cycle count: ${cycles}. Must be between 1 and 1000`);
    }
    
    const data = {
        api_key: apiKey,
        address: address,
        cycles: cycles
    };
    
    try {
        const response = await axios.post(url, data, {
            headers: {
                'Content-Type': 'application/json'
            },
            timeout: 30000
        });
        
        const result = response.data;
        
        if (result.code === 0) {
            console.log(`✅ Successfully purchased ${result.data.cycles_purchased} cycles`);
            console.log(`Address: ${result.data.address}`);
            console.log(`Total cycles: ${result.data.total_cycles}`);
            console.log(`Total cost: ${result.data.total_cost} TRX`);
            console.log(`Next delegation: ${result.data.next_delegation_time || 'N/A'}`);
        } else {
            console.error(`❌ Error: ${result.msg}`);
        }
        
        return result;
        
    } catch (error) {
        if (error.response) {
            console.error(`❌ API Error: ${error.response.status} - ${error.response.data?.msg || error.message}`);
        } else if (error.request) {
            console.error('❌ No response from server');
        } else {
            console.error(`❌ Request failed: ${error.message}`);
        }
        throw error;
    }
}

// Example usage
(async () => {
    const API_KEY = 'YOUR_API_KEY_HERE';
    const ADDRESS = 'TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE';
    const CYCLES = 10;
    
    try {
        const result = await orderCycles(API_KEY, ADDRESS, CYCLES);
        console.log('Result:', result);
    } catch (error) {
        console.error('Failed to order cycles:', error.message);
    }
})();

PHP

<?php

/**
 * Purchase energy delegation cycles for a TRON address in Host Mode
 * 
 * @param string $apiKey Your API authentication key
 * @param string $address TRON address to purchase cycles for
 * @param int $cycles Number of cycles to purchase (1-1000)
 * @return array API response
 */
function orderCycles($apiKey, $address, $cycles) {
    $url = 'https://netts.io/apiv2/time/order';
    
    // Validate address format
    if (!preg_match('/^T[1-9A-HJ-NP-Za-km-z]{33}$/', $address)) {
        throw new InvalidArgumentException("Invalid TRON address format: $address");
    }
    
    // Validate cycle count
    if (!is_int($cycles) || $cycles < 1 || $cycles > 1000) {
        throw new InvalidArgumentException("Invalid cycle count: $cycles. Must be between 1 and 1000");
    }
    
    $data = [
        'api_key' => $apiKey,
        'address' => $address,
        'cycles' => $cycles
    ];
    
    $options = [
        'http' => [
            'header' => "Content-Type: application/json\r\n",
            'method' => 'POST',
            'content' => json_encode($data),
            'timeout' => 30
        ]
    ];
    
    $context = stream_context_create($options);
    $response = @file_get_contents($url, false, $context);
    
    if ($response === false) {
        $error = error_get_last();
        throw new RuntimeException('Request failed: ' . $error['message']);
    }
    
    $result = json_decode($response, true);
    
    if ($result['code'] == 0) {
        echo "✅ Successfully purchased {$result['data']['cycles_purchased']} cycles\n";
        echo "Address: {$result['data']['address']}\n";
        echo "Total cycles: {$result['data']['total_cycles']}\n";
        echo "Total cost: {$result['data']['total_cost']} TRX\n";
    } else {
        echo "❌ Error: {$result['msg']}\n";
    }
    
    return $result;
}

// Example usage
$API_KEY = 'YOUR_API_KEY_HERE';
$ADDRESS = 'TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE';
$CYCLES = 10;

try {
    $result = orderCycles($API_KEY, $ADDRESS, $CYCLES);
    print_r($result);
} catch (Exception $e) {
    echo "Failed to order cycles: " . $e->getMessage() . "\n";
}
?>

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

// OrderRequest represents the API request structure
type OrderRequest struct {
    APIKey  string `json:"api_key"`
    Address string `json:"address"`
    Cycles  int    `json:"cycles"`
}

// OrderResponse represents the API response structure
type OrderResponse struct {
    Code int    `json:"code"`
    Msg  string `json:"msg"`
    Data struct {
        Address          string  `json:"address"`
        CyclesPurchased  int     `json:"cycles_purchased"`
        TotalCycles      int     `json:"total_cycles"`
        TotalCost        float64 `json:"total_cost"`
        PricePerCycle    float64 `json:"price_per_cycle"`
        OrderID          string  `json:"order_id"`
        TransactionHash  string  `json:"transaction_hash"`
        NextDelegation   int64   `json:"next_delegation_time"`
    } `json:"data"`
}

// OrderCycles purchases energy delegation cycles for a TRON address
func OrderCycles(apiKey, address string, cycles int) (*OrderResponse, error) {
    url := "https://netts.io/apiv2/time/order"
    
    // Validate address format
    if len(address) != 34 || address[0] != 'T' {
        return nil, fmt.Errorf("invalid TRON address format: %s", address)
    }
    
    // Validate cycle count
    if cycles < 1 || cycles > 1000 {
        return nil, fmt.Errorf("invalid cycle count: %d. Must be between 1 and 1000", cycles)
    }
    
    // Create request
    reqData := OrderRequest{
        APIKey:  apiKey,
        Address: address,
        Cycles:  cycles,
    }
    
    jsonData, err := json.Marshal(reqData)
    if err != nil {
        return nil, err
    }
    
    // Make HTTP request
    client := &http.Client{Timeout: 30 * time.Second}
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    // Read response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    // Parse response
    var result OrderResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }
    
    if result.Code == 0 {
        fmt.Printf("✅ Successfully purchased %d cycles\n", result.Data.CyclesPurchased)
        fmt.Printf("Address: %s\n", result.Data.Address)
        fmt.Printf("Total cycles: %d\n", result.Data.TotalCycles)
        fmt.Printf("Total cost: %.2f TRX\n", result.Data.TotalCost)
    } else {
        fmt.Printf("❌ Error: %s\n", result.Msg)
    }
    
    return &result, nil
}

func main() {
    apiKey := "YOUR_API_KEY_HERE"
    address := "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE"
    cycles := 10
    
    result, err := OrderCycles(apiKey, address, cycles)
    if err != nil {
        fmt.Printf("Failed to order cycles: %v\n", err)
        return
    }
    
    fmt.Printf("Order ID: %s\n", result.Data.OrderID)
}

Respuesta

Respuesta exitosa (200 OK)

{
    "code": 0,
    "msg": "Cycles successfully purchased",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "cycles_purchased": 10,
        "total_cycles": 25,
        "previous_cycles": 15,
        "total_cost": 30.0,
        "price_per_cycle": 3.0,
        "discount_applied": 0,
        "order_id": "ORD-20231109-A7C9F2B3",
        "transaction_hash": "b8d4f1a2c7e9b3d5f8a1c4e7b9d2f5a8c1e4f8b2d5f8c1e4b7d2f5a8c1e4f8b2",
        "payment_method": "account_balance",
        "balance_after": 470.0,
        "next_delegation_time": 1699615200,
        "expiry_time": 1701475200,
        "status": "confirmed"
    }
}

Campos de Respuesta

Field	Type	Description
code	integer	Status code (0 for success, -1 for error)
msg	string	Human-readable status message
data	object	Response data object
data.address	string	The TRON address cycles were purchased for
data.cycles_purchased	integer	Number of cycles purchased in this order
data.total_cycles	integer	Total cycles now available for the address
data.previous_cycles	integer	Number of cycles before this purchase
data.total_cost	number	Total cost in TRX for this order
data.price_per_cycle	number	Price per cycle in TRX
data.discount_applied	number	Discount amount applied (if any)
data.order_id	string	Unique order identifier for tracking
data.transaction_hash	string	TRON blockchain transaction hash
data.payment_method	string	Payment method used ("account_balance", "card", "crypto")
data.balance_after	number	Account balance after purchase
data.next_delegation_time	integer	Unix timestamp for next energy delegation
data.expiry_time	integer	Unix timestamp when last cycle expires
data.status	string	Order status ("confirmed", "pending", "processing")

Respuestas de Error

Error de Autenticación (401)

{
    "code": -1,
    "msg": "Invalid API key",
    "data": null
}

Causes:

• Invalid or expired API key
• API key not found in system
• Account suspended or terminated

Resolution:

• Verify API key is correct
• Check account status in dashboard
• Contact support if key should be valid

Dirección no encontrada (404)

{
    "code": -1,
    "msg": "Address not found in Host Mode",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "suggestion": "Use /time/add to add this address to Host Mode first"
    }
}

Causes:

• Address not in Host Mode
• Address was deleted from Host Mode
• Address belongs to different API key

Resolution:

• Add address to Host Mode using /time/add first
• Verify address ownership
• Check address status with /time/status

Saldo Insuficiente (402)

{
    "code": -1,
    "msg": "Insufficient balance to purchase cycles",
    "data": {
        "required_amount": 30.0,
        "current_balance": 10.0,
        "deficit": 20.0,
        "cycles_requested": 10,
        "price_per_cycle": 3.0
    }
}

Causes:

• Account balance too low for purchase
• Credit limit exceeded
• Payment method declined

Resolution:

• Add funds to your account
• Reduce number of cycles requested
• Check payment method status
• Contact support for credit increase

Recuento de Ciclo No Válido (400)

{
    "code": -1,
    "msg": "Invalid cycle count",
    "data": {
        "requested": 1500,
        "minimum": 1,
        "maximum": 1000,
        "suggestion": "For bulk orders over 1000 cycles, contact support"
    }
}

Causes:

• Cycles less than 1 or greater than 1000
• Non-integer value provided
• Exceeds account limits

Resolution:

• Ensure cycles between 1 and 1000
• Use integer values only
• Contact support for bulk orders
• Check account cycle limits

Dirección en Modo Infinito (409)

{
    "code": -1,
    "msg": "Cannot purchase cycles for address in infinity mode",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "mode": "infinity",
        "suggestion": "Infinity mode provides unlimited cycles automatically"
    }
}

Causes:

• Address has infinity mode enabled
• Infinity mode incompatible with cycle purchases
• Mode conflict detected

Resolution:

• No action needed - infinity mode provides unlimited cycles
• Disable infinity mode if you prefer manual cycle purchases
• Use /time/status to check current mode

Ciclos Máximos Superados (409)

{
    "code": -1,
    "msg": "Maximum cycle limit exceeded",
    "data": {
        "current_cycles": 9500,
        "requested_cycles": 600,
        "total_would_be": 10100,
        "maximum_allowed": 10000,
        "available_to_purchase": 500
    }
}

Causes:

• Total cycles would exceed 10,000 limit
• Account has cycle cap restrictions
• Safety limit reached

Resolution:

• Purchase fewer cycles (max available shown)
• Use existing cycles before purchasing more
• Consider infinity mode for unlimited cycles
• Contact support to increase limits

Pedido Pendiente Existente (409)

{
    "code": -1,
    "msg": "Pending order already exists for this address",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "pending_order_id": "ORD-20231109-X3D5F7A9",
        "status": "processing",
        "retry_after": 60
    }
}

Causes:

• Previous order still processing
• Duplicate order attempt
• Transaction not yet confirmed

Resolution:

• Wait for pending order to complete
• Check order status with order ID
• Retry after specified time
• Contact support if order stuck

Límites de Tasa

Period	Limit	Description
1 minute	6 requests	Maximum 6 requests per minute per API key
1 hour	100 requests	Maximum 100 requests per hour per API key
1 day	1000 requests	Maximum 1000 requests per day per API key

Encabezados de Límite de Tasa

X-RateLimit-Limit-Minute: 6
X-RateLimit-Remaining-Minute: 5
X-RateLimit-Reset-Minute: 1699528860

X-RateLimit-Limit-Hour: 100
X-RateLimit-Remaining-Hour: 98
X-RateLimit-Reset-Hour: 1699532400

X-RateLimit-Limit-Day: 1000
X-RateLimit-Remaining-Day: 995
X-RateLimit-Reset-Day: 1699574400

Respuesta de Límite de Tasa Excedido (429)

{
    "code": -1,
    "msg": "API rate limit exceeded",
    "data": {
        "retry_after": 45,
        "limit": "6 per minute",
        "reset_at": 1699528860
    }
}

Comprender los Ciclos

¿Qué es un Ciclo?

Un ciclo representa un período de 24 horas de delegación de energía que proporciona:

• Energy Amount: 131,000 energy units
• Duration: 24 hours from activation
• Auto-activation: Next cycle starts automatically when current expires
• Stackable: Multiple cycles queue sequentially

Ciclo de Vida

1. Purchase: Cycles added to address queue
2. Activation: First cycle starts immediately or when current expires
3. Delegation: Energy delegated to address on blockchain
4. Usage: Address can use energy for transactions
5. Expiration: After 24 hours, cycle ends
6. Next Cycle: If available, next cycle auto-starts

Precios del Ciclo

Quantity	Price per Cycle	Total Cost	Discount
1-9	3.0 TRX	Qty × 3.0	0%
10-49	2.8 TRX	Qty × 2.8	7%
50-99	2.6 TRX	Qty × 2.6	13%
100-499	2.4 TRX	Qty × 2.4	20%
500-999	2.2 TRX	Qty × 2.2	27%
1000+	Contact Support	Custom	30%+

Gestión de Ciclos

• Queue System: Cycles queue in order of purchase
• No Overlap: Cycles don't run simultaneously
• No Waste: Unused energy doesn't carry over
• Refills: Can purchase more cycles anytime
• Maximum: 10,000 cycles per address

Impacto del Modo Anfitrión

Cómo funcionan los ciclos en el modo Host

1. Automatic Management: Host Mode handles cycle activation
2. Sequential Processing: Cycles activate one after another
3. No Manual Intervention: System manages everything
4. Energy Guarantee: 131,000 energy per cycle guaranteed
5. Continuous Operation: No gaps between cycles

Ciclo vs. Modo Infinito

Feature	Cycle Mode	Infinity Mode
Purchase Method	Buy specific quantity	Unlimited auto-renew
Billing	Prepaid per cycle	Daily subscription
Flexibility	Full control	Set and forget
Best For	Variable usage	Constant usage
Minimum Commitment	1 cycle	Daily billing
Price Predictability	Fixed prepaid	Fixed daily rate

Facturación y Pago

Proceso de Pago

1. Calculation: System calculates total cost with discounts
2. Balance Check: Verifies sufficient account balance
3. Deduction: Amount deducted from account
4. Confirmation: Order confirmed and cycles added
5. Receipt: Email receipt sent with details

Métodos de Pago

• Account Balance: Primary payment method
• Auto-recharge: Automatic top-up when low
• Credit Card: Stored cards for quick payment
• Cryptocurrency: Bitcoin, Ethereum, USDT accepted
• Wire Transfer: For enterprise accounts

Detalles de Facturación

• Immediate Charge: Payment processed instantly
• No Recurring: One-time payment per order
• Volume Discounts: Automatic for larger orders
• Tax Included: Prices include applicable taxes
• Invoicing: Available for business accounts

Consideraciones de Seguridad

Seguridad de Autenticación

• API Key Storage: Never expose API keys in client-side code
• HTTPS Only: All requests must use HTTPS
• IP Whitelist: Configure IP whitelist for production use
• Key Rotation: Rotate API keys regularly

Seguridad del Pedido

1. Duplicate Prevention: System prevents duplicate orders
2. Idempotency: Same request won't create multiple orders
3. Transaction Verification: Blockchain confirmation required
4. Audit Trail: All orders logged with details

Comprobaciones de Validación

1. Validación de la Clave API

   • Key exists and is active
   • Account has sufficient balance
   • Not exceeded rate limits

2. Verificación de Dirección

   • Address in Host Mode
   • Owned by API key account
   • Not in infinity mode

3. Validación de Ciclo

   • Valid integer range
   • Within account limits
   • Total doesn't exceed maximum

4. Integridad de la Solicitud

   • Valid JSON format
   • Required fields present
   • No injection attempts

Arquitectura Técnica

Componentes del Servicio

1. Puerta de enlace API

   • Request validation and routing
   • Rate limiting enforcement
   • IP whitelist checking

2. Servicio de Procesamiento de Órdenes

   • Order validation and creation
   • Pricing calculation
   • Discount application

3. Servicio de Pago

   • Balance verification
   • Payment processing
   • Receipt generation

4. Servicio de Gestión de Ciclos

   • Cycle queue management
   • Activation scheduling
   • Expiry tracking

5. Servicio Blockchain

   • Energy delegation execution
   • Transaction confirmation
   • On-chain verification

6. Capa de Base de Datos

   • PostgreSQL for order data
   • Redis for caching and queues
   • Time-series for usage tracking

Flujo de la Petición

1. Client sends POST request with API key, address, and cycles
2. API Gateway validates request format and rate limits
3. Authentication Service verifies API key and permissions
4. Order Processing Service calculates pricing with discounts
5. Payment Service processes payment from account balance
6. Cycle Management Service adds cycles to address queue
7. Blockchain Service prepares delegation transactions
8. Response sent to client with order details

Pipeline de Procesamiento de Órdenes

1. Etapa de Validación

   • Input validation
   • Business rule checks
   • Fraud detection

2. Etapa de Precios

   • Base price calculation
   • Discount application
   • Tax calculation

3. Etapa de Pago

   • Balance verification
   • Payment execution
   • Transaction recording

4. Etapa de Cumplimiento

   • Cycle allocation
   • Queue update
   • Notification dispatch

Puntos Finales Relacionados

• POST /apiv2/time/add - Add address to Host Mode (required first)
• "POST /apiv2/time/status" - Check current cycles and status
• POST /apiv2/time/infinitystart - Switch to unlimited cycles
• "POST /apiv2/time/stop" - Pause cycle consumption
• POST /apiv2/time/delete - Remove from Host Mode

Mejores Prácticas

Cuándo solicitar ciclos

• Regular Usage: Order weekly/monthly batches
• Project-Based: Order cycles for project duration
• Testing: Start with small quantities
• Production: Maintain buffer of cycles

Cantidades Óptimas de Órdenes

1. Small Projects: 10-50 cycles
2. Medium Usage: 100-500 cycles
3. High Usage: 500-1000 cycles
4. Enterprise: Custom bulk orders

Optimización de Costos

• Bulk Purchases: Take advantage of volume discounts
• Plan Ahead: Order larger quantities for better rates
• Monitor Usage: Track consumption patterns
• Consider Infinity: For constant usage, infinity mode may be cheaper

Gestión de Órdenes

1. Track Orders: Save order IDs for reference
2. Monitor Balance: Ensure sufficient funds
3. Set Alerts: Configure low cycle warnings
4. Review Usage: Analyze cycle consumption

Solución de problemas

Problemas Comunes

"Saldo insuficiente"

Problema: Fondos insuficientes para comprar los ciclos solicitados

Solutions:

• Check account balance in dashboard
• Add funds to account
• Reduce number of cycles
• Check for pending charges

"Dirección no en modo host"

Problema: Intentando solicitar ciclos para una dirección que no está en modo Host

Solutions:

• Add address using /time/add endpoint first
• Verify address status with /time/status
• Check using correct API key
• Ensure address format is correct

"Se excedieron los ciclos máximos"

Problema: El pedido excedería el límite de 10,000 ciclos

Solutions:

• Check current cycle count with /time/status
• Calculate available capacity
• Use some cycles before ordering more
• Consider infinity mode for unlimited

"Recuento de ciclo no válido"

Problema: Parámetro de ciclo fuera del rango válido

Solutions:

• Ensure cycles between 1 and 1000
• Use integer values only
• Check for typos in request
• Validate input before sending

Problemas con los Pedidos

Orden atascada en procesamiento

Síntomas: El estado del pedido permanece como "procesando"

Solutions:

• Wait up to 5 minutes for confirmation
• Check blockchain transaction status
• Verify network isn't congested
• Contact support with order ID

Ciclos no visibles

Síntomas: Ciclos comprados no se muestran en el estado

Solutions:

• Allow 1-2 minutes for update
• Check order confirmation response
• Verify correct address was used
• Use /time/status to refresh

Pago Fallido

Síntomas: Rechazo del pedido debido a un problema de pago

Solutions:

• Verify account balance sufficient
• Check payment method valid
• Ensure no account restrictions
• Contact support for payment help

Obteniendo Ayuda

Si encuentra problemas no cubiertos aquí:

1. Check Documentation: Review this guide and related endpoints
2. API Status: Check https://status.netts.io for service status
3. Order History: Review orders in dashboard
4. Support Ticket: Submit ticket with order ID
5. Emergency: Use emergency contact for urgent issues

Webhooks

Eventos Webhook Disponibles

• order.created: New order placed
• order.confirmed: Order payment confirmed
• order.fulfilled: Cycles added to address
• order.failed: Order failed to process
• cycle.activated: New cycle started
• cycle.expiring: Cycle about to expire
• cycles.low: Running low on cycles

Configuración de Webhook

{
    "url": "https://your-server.com/webhooks",
    "events": ["order.confirmed", "cycles.low"],
    "secret": "your_webhook_secret"
}

Ejemplo de Carga Útil de Webhook

{
    "event": "order.confirmed",
    "timestamp": 1699528800,
    "data": {
        "order_id": "ORD-20231109-A7C9F2B3",
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "cycles": 10,
        "total_cost": 30.0,
        "api_key_id": "key_123***"
    },
    "signature": "sha256=abc123..."
}

Notas

• Prerequisites: Address must be in Host Mode via /time/add first
• Immediate Processing: Orders are processed instantly upon payment
• No Cancellation: Purchased cycles cannot be cancelled or refunded
• Transferability: Cycles cannot be transferred between addresses
• Expiry: Unused cycles don't expire but remain queued
• Stacking: Multiple orders stack sequentially, not concurrently
• Price Changes: Prices locked at time of purchase
• Bulk Orders: Contact support for orders over 1000 cycles
• API Versioning: This is v2 API; v1 uses different pricing
• Maintenance: Orders continue processing during maintenance
• Network Issues: Orders retry automatically if network issues occur
• Order History: Full order history available in dashboard
• Tax Invoices: Available for business accounts on request
• Discounts: Volume discounts applied automatically
• Monitoring: Real-time cycle usage monitoring in dashboard