POST /apiv2/time/order

Purchase specific energy delegation cycles for a TRON address in Host Mode.

Overview

The Time Order endpoint allows you to purchase a specific number of energy delegation cycles for an address that's already in Host Mode. Each cycle provides 131,000 energy for 24 hours. This endpoint is ideal for precise control over energy allocation and budget management, allowing you to purchase exactly the number of cycles needed for your operations.

Endpoint URL

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

Authentication

This endpoint uses JSON body authentication (not headers). Your API key, target address, and desired cycle count are provided in the request body.

Authentication Flow

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

Request Headers

Header	Required	Description
Content-Type	Yes	application/json

Request Body

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

Parameters

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

Parameter Validation

• 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

Example Requests

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)
}

Response

Success Response (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"
    }
}

Response Fields

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")

Error Responses

Authentication Error (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

Address Not Found (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

Insufficient Balance (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

Invalid Cycle Count (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

Address in Infinity Mode (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

Maximum Cycles Exceeded (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

Pending Order Exists (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

Rate Limits

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

Rate Limit Headers

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

Rate Limit Exceeded Response (429)

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

Understanding Cycles

What is a Cycle?

A cycle represents one 24-hour period of energy delegation providing:

• 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

Cycle Lifecycle

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

Cycle Pricing

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%+

Cycle Management

• 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

Host Mode Impact

How Cycles Work in Host Mode

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

Cycle vs Infinity Mode

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

Billing and Payment

Payment Process

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

Payment Methods

• 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

Billing Details

• 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

Security Considerations

Authentication Security

• 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

Order Security

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

Validation Checks

1. API Key Validation

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

2. Address Verification

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

3. Cycle Validation

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

4. Request Integrity

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

Technical Architecture

Service Components

1. API Gateway

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

2. Order Processing Service

   • Order validation and creation
   • Pricing calculation
   • Discount application

3. Payment Service

   • Balance verification
   • Payment processing
   • Receipt generation

4. Cycle Management Service

   • Cycle queue management
   • Activation scheduling
   • Expiry tracking

5. Blockchain Service

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

6. Database Layer

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

Request Flow

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

Order Processing Pipeline

1. Validation Stage

   • Input validation
   • Business rule checks
   • Fraud detection

2. Pricing Stage

   • Base price calculation
   • Discount application
   • Tax calculation

3. Payment Stage

   • Balance verification
   • Payment execution
   • Transaction recording

4. Fulfillment Stage

   • Cycle allocation
   • Queue update
   • Notification dispatch

Related Endpoints

• 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

Best Practices

When to Order Cycles

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

Optimal Order Quantities

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

Cost Optimization

• 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

Order Management

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

Troubleshooting

Common Issues

"Insufficient balance"

Problem: Not enough funds to purchase requested cycles

Solutions:

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

"Address not in Host Mode"

Problem: Trying to order cycles for non-Host Mode address

Solutions:

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

"Maximum cycles exceeded"

Problem: Order would exceed 10,000 cycle limit

Solutions:

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

"Invalid cycle count"

Problem: Cycle parameter outside valid range

Solutions:

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

Order Issues

Order Stuck in Processing

Symptoms: Order status remains "processing"

Solutions:

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

Cycles Not Appearing

Symptoms: Purchased cycles not showing in status

Solutions:

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

Payment Failed

Symptoms: Order rejected due to payment issue

Solutions:

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

Getting Help

If you encounter issues not covered here:

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

Available Webhook Events

• 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

Webhook Configuration

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

Webhook Payload Example

{
    "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..."
}

Notes

• 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