Skip to content

POST /apiv2/time/infinitystart

Enable unlimited energy delegation cycles for a TRON address in Host Mode.

Overview

The Time Infinity Start endpoint activates unlimited cycle mode for a TRON address that's already in Host Mode. Once enabled, the address will receive continuous 131,000 energy delegations without cycle limitations, ensuring uninterrupted energy supply for high-frequency operations or smart contracts that require constant energy availability.

Endpoint URL

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

Authentication

This endpoint uses JSON body authentication (not headers). Your API key and target address 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 infinity mode
  5. Status Verification: Address must already be in Host Mode

Request Headers

HeaderRequiredDescription
Content-TypeYesapplication/json

Request Body

json
{
    "api_key": "your_api_key",
    "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE"
}

Parameters

ParameterTypeRequiredValidationDescription
api_keystringYesMust exist in systemYour API key for authentication and billing
addressstringYesTRC-20 formatTRON address to enable infinity mode (must start with 'T' and be 34 characters)

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 have infinity mode permissions
    • Account balance must support infinity mode billing
  • 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 already be in infinity mode
    • Must have completed at least one standard cycle
    • Cannot have pending transactions
  • 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

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

Python

python
import requests
import json
from typing import Dict, Optional

def enable_infinity_mode(api_key: str, address: str) -> Dict:
    """
    Enable unlimited cycles for a TRON address in Host Mode.
    
    Args:
        api_key: Your API authentication key
        address: TRON address to enable infinity mode
        
    Returns:
        API response dictionary
    """
    url = "https://netts.io/apiv2/time/infinitystart"
    
    # Validate address format
    if not address.startswith('T') or len(address) != 34:
        raise ValueError(f"Invalid TRON address format: {address}")
    
    data = {
        "api_key": api_key,
        "address": address
    }
    
    try:
        response = requests.post(url, json=data, verify=True, timeout=30)
        response.raise_for_status()
        
        result = response.json()
        
        if result['code'] == 0:
            print(f"✅ Infinity mode enabled for: {result['data']['address']}")
            print(f"Mode: {result['data']['mode']}")
            print(f"Daily cost: {result['data'].get('daily_cost', 'N/A')} TRX")
            print(f"Energy per cycle: {result['data'].get('energy_per_cycle', 131000)}")
        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"
    
    result = enable_infinity_mode(API_KEY, ADDRESS)

Node.js

javascript
const axios = require('axios');

/**
 * Enable unlimited cycles for a TRON address in Host Mode
 * @param {string} apiKey - Your API authentication key
 * @param {string} address - TRON address to enable infinity mode
 * @returns {Promise<Object>} API response
 */
async function enableInfinityMode(apiKey, address) {
    const url = 'https://netts.io/apiv2/time/infinitystart';
    
    // Validate address format
    if (!address.startsWith('T') || address.length !== 34) {
        throw new Error(`Invalid TRON address format: ${address}`);
    }
    
    const data = {
        api_key: apiKey,
        address: address
    };
    
    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(`✅ Infinity mode enabled for: ${result.data.address}`);
            console.log(`Mode: ${result.data.mode}`);
            console.log(`Daily cost: ${result.data.daily_cost || 'N/A'} TRX`);
            console.log(`Energy per cycle: ${result.data.energy_per_cycle || 131000}`);
        } 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';
    
    try {
        const result = await enableInfinityMode(API_KEY, ADDRESS);
        console.log('Result:', result);
    } catch (error) {
        console.error('Failed to enable infinity mode:', error.message);
    }
})();

PHP

php
<?php

/**
 * Enable unlimited cycles for a TRON address in Host Mode
 * 
 * @param string $apiKey Your API authentication key
 * @param string $address TRON address to enable infinity mode
 * @return array API response
 */
function enableInfinityMode($apiKey, $address) {
    $url = 'https://netts.io/apiv2/time/infinitystart';
    
    // Validate address format
    if (!preg_match('/^T[1-9A-HJ-NP-Za-km-z]{33}$/', $address)) {
        throw new InvalidArgumentException("Invalid TRON address format: $address");
    }
    
    $data = [
        'api_key' => $apiKey,
        'address' => $address
    ];
    
    $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 "✅ Infinity mode enabled for: {$result['data']['address']}\n";
        echo "Mode: {$result['data']['mode']}\n";
        echo "Daily cost: " . ($result['data']['daily_cost'] ?? 'N/A') . " TRX\n";
        echo "Energy per cycle: " . ($result['data']['energy_per_cycle'] ?? 131000) . "\n";
    } else {
        echo "❌ Error: {$result['msg']}\n";
    }
    
    return $result;
}

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

try {
    $result = enableInfinityMode($API_KEY, $ADDRESS);
    print_r($result);
} catch (Exception $e) {
    echo "Failed to enable infinity mode: " . $e->getMessage() . "\n";
}
?>

Java

java
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class InfinityModeExample {
    
    private static final String API_URL = "https://netts.io/apiv2/time/infinitystart";
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();
    private static final Gson gson = new Gson();
    
    /**
     * Enable unlimited cycles for a TRON address in Host Mode
     * @param apiKey Your API authentication key
     * @param address TRON address to enable infinity mode
     * @return API response as JsonObject
     */
    public static JsonObject enableInfinityMode(String apiKey, String address) throws Exception {
        // Validate address format
        if (!address.startsWith("T") || address.length() != 34) {
            throw new IllegalArgumentException("Invalid TRON address format: " + address);
        }
        
        // Create request body
        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("api_key", apiKey);
        requestBody.addProperty("address", address);
        
        // Build HTTP request
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(requestBody)))
                .timeout(Duration.ofSeconds(30))
                .build();
        
        // Send request and get response
        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        
        // Parse response
        JsonObject result = gson.fromJson(response.body(), JsonObject.class);
        
        if (result.get("code").getAsInt() == 0) {
            JsonObject data = result.getAsJsonObject("data");
            System.out.println("✅ Infinity mode enabled for: " + data.get("address").getAsString());
            System.out.println("Mode: " + data.get("mode").getAsString());
            if (data.has("daily_cost")) {
                System.out.println("Daily cost: " + data.get("daily_cost").getAsString() + " TRX");
            }
        } else {
            System.err.println("❌ Error: " + result.get("msg").getAsString());
        }
        
        return result;
    }
    
    public static void main(String[] args) {
        String API_KEY = "YOUR_API_KEY_HERE";
        String ADDRESS = "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE";
        
        try {
            JsonObject result = enableInfinityMode(API_KEY, ADDRESS);
            System.out.println("Result: " + result);
        } catch (Exception e) {
            System.err.println("Failed to enable infinity mode: " + e.getMessage());
        }
    }
}

Response

Success Response (200 OK)

json
{
    "code": 0,
    "msg": "Infinity mode successfully enabled",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "mode": "infinity",
        "status": "active",
        "energy_per_cycle": 131000,
        "cycle_duration": 86400,
        "daily_cost": 30,
        "billing_cycle": "daily",
        "activated_at": 1699528800,
        "next_billing": 1699615200,
        "auto_renew": true,
        "transaction_hash": "a7c9f2b3d8e1a5c7f9b3d5e7a1c3e5f7b9d1f3a5c7e9b1d3f5a7c9e1b3d5f7a9"
    }
}

Response Fields

FieldTypeDescription
codeintegerStatus code (0 for success, -1 for error)
msgstringHuman-readable status message
dataobjectResponse data object
data.addressstringThe TRON address with infinity mode enabled
data.modestringCurrent mode ("infinity")
data.statusstringCurrent status ("active", "pending", "processing")
data.energy_per_cycleintegerEnergy amount per delegation cycle (131,000)
data.cycle_durationintegerDuration of each cycle in seconds (86,400 = 24 hours)
data.daily_costnumberDaily cost in TRX for infinity mode
data.billing_cyclestringBilling period ("daily", "weekly", "monthly")
data.activated_atintegerUnix timestamp when infinity mode was activated
data.next_billingintegerUnix timestamp for next billing cycle
data.auto_renewbooleanWhether infinity mode auto-renews
data.transaction_hashstringTRON blockchain transaction hash for the activation

Error Responses

Authentication Error (401)

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

json
{
    "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

Already in Infinity Mode (409)

json
{
    "code": -1,
    "msg": "Address already in infinity mode",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "mode": "infinity",
        "activated_at": 1699442400,
        "daily_cost": 30
    }
}

Causes:

  • Address already has infinity mode enabled
  • Previous activation still active
  • Duplicate request

Resolution:

  • Check current status with /time/status
  • No action needed if already active
  • Use /time/stop to disable if needed

Insufficient Balance (402)

json
{
    "code": -1,
    "msg": "Insufficient balance for infinity mode",
    "data": {
        "required_balance": 300,
        "current_balance": 50,
        "deficit": 250,
        "billing_cycle": "daily",
        "daily_cost": 30
    }
}

Causes:

  • Account balance too low for infinity mode
  • Minimum balance requirement not met
  • Credit limit exceeded

Resolution:

  • Add funds to your account
  • Check minimum balance requirements
  • Contact support for credit limit increase
  • Consider standard cycle mode instead

Invalid Address Format (400)

json
{
    "code": -1,
    "msg": "Invalid TRON address format",
    "data": {
        "address": "invalid_address",
        "format": "Address must start with 'T' and be 34 characters long"
    }
}

Causes:

  • Address doesn't match TRC-20 format
  • Address contains invalid characters
  • Address wrong length

Resolution:

  • Verify address starts with 'T'
  • Ensure address is exactly 34 characters
  • Check for typos or copy/paste errors

Permission Denied (403)

json
{
    "code": -1,
    "msg": "Infinity mode not enabled for this account",
    "data": {
        "account_type": "basic",
        "required_type": "premium",
        "upgrade_url": "https://netts.io/upgrade"
    }
}

Causes:

  • Account type doesn't support infinity mode
  • Feature not enabled for account
  • Trial account limitations

Resolution:

  • Upgrade account to premium tier
  • Contact support to enable feature
  • Check account permissions in dashboard

Pending Operations (409)

json
{
    "code": -1,
    "msg": "Cannot enable infinity mode with pending operations",
    "data": {
        "address": "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE",
        "pending_operation": "cycle_purchase",
        "retry_after": 300
    }
}

Causes:

  • Address has pending cycle purchases
  • Active delegation in progress
  • Previous mode change not completed

Resolution:

  • Wait for pending operations to complete
  • Retry after specified time
  • Check operation status with /time/status

Rate Limits

PeriodLimitDescription
1 minute6 requestsMaximum 6 requests per minute per API key
1 hour100 requestsMaximum 100 requests per hour per API key
1 day1000 requestsMaximum 1000 requests per day per API key

Rate Limit Headers

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

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

What is Infinity Mode?

Key Features

  1. Unlimited Cycles

    • No cycle count limitations
    • Continuous energy delegation
    • Never runs out of energy
    • Automatic renewal every 24 hours
  2. Predictable Billing

    • Fixed daily cost
    • No per-cycle charges
    • Simplified accounting
    • Volume discounts available
  3. Priority Processing

    • Higher priority in delegation queue
    • Faster energy allocation
    • Guaranteed availability
    • Premium support

How It Works

  1. Activation Process

    • Address must be in Host Mode first
    • Infinity mode enabled via this endpoint
    • Initial billing cycle starts immediately
    • Energy delegation continues uninterrupted
  2. Energy Management

    • 131,000 energy delegated every 24 hours
    • Automatic renewal at cycle end
    • No manual intervention required
    • Smart usage optimization
  3. Billing Cycle

    • Daily charges at fixed rate
    • Automatic deduction from balance
    • Email notifications before renewal
    • Can be cancelled anytime

Comparison with Standard Mode

FeatureStandard ModeInfinity Mode
CyclesLimited (purchased)Unlimited
BillingPer cycleDaily flat rate
PriorityStandardHigh
Auto-renewalNoYes
Energy Amount131,000131,000
Minimum BalanceNoneRequired
Best ForOccasional useContinuous operations

Host Mode Impact

Before Infinity Mode

  • Limited number of purchased cycles
  • Manual cycle purchases required
  • Risk of running out of energy
  • Variable monthly costs
  • Standard processing priority

After Infinity Mode

  • Unlimited energy cycles
  • Automatic daily renewals
  • Never runs out of energy
  • Fixed predictable costs
  • Priority processing queue
  • Premium support access

Billing and Costs

Cost Structure

  • Daily Rate: 30 TRX per day (example rate)
  • Weekly Rate: 200 TRX per week (discounted)
  • Monthly Rate: 750 TRX per month (best value)
  • Annual Rate: 8,000 TRX per year (maximum discount)

Billing Process

  1. Initial Charge

    • First billing cycle charged immediately
    • Prorated if activated mid-cycle
    • Receipt sent via email
  2. Recurring Charges

    • Automatic daily deduction
    • Processed at UTC midnight
    • Failed payments retry 3 times
  3. Balance Requirements

    • Minimum balance: 10x daily rate
    • Low balance warnings at 5 days remaining
    • Auto-suspend if balance insufficient

Payment Methods

  • Account balance (primary)
  • Auto-recharge from card
  • Cryptocurrency payments
  • Wire transfers (enterprise)

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

Validation Checks

  1. API Key Validation

    • Key exists and is active
    • Account has infinity mode permissions
    • Sufficient balance available
  2. Address Verification

    • Address in Host Mode
    • Owned by API key account
    • No conflicting operations
  3. Request Integrity

    • Valid JSON format
    • Required fields present
    • No injection attempts
    • Rate limits enforced

Audit Trail

All infinity mode activations are logged with:

  • Timestamp
  • API key used
  • IP address
  • Address activated
  • Billing details
  • Transaction hash

Technical Architecture

Service Components

  1. API Gateway

    • Request validation and routing
    • Rate limiting enforcement
    • IP whitelist checking
  2. Authentication Service

    • API key validation
    • Permission checking
    • Balance verification
  3. Infinity Mode Manager

    • Mode activation logic
    • Billing cycle management
    • Auto-renewal processing
  4. Energy Scheduler

    • Continuous delegation scheduling
    • Priority queue management
    • Resource optimization
  5. Billing Service

    • Payment processing
    • Balance management
    • Invoice generation
  6. Database Layer

    • PostgreSQL for persistent data
    • Redis for caching and sessions
    • Time-series data for usage analytics

Request Flow

  1. Client sends POST request with API key and address
  2. API Gateway validates request format and rate limits
  3. Authentication Service verifies API key and permissions
  4. Balance check ensures sufficient funds
  5. Infinity Mode Manager activates unlimited cycles
  6. Energy Scheduler updates delegation queue
  7. Billing Service processes initial payment
  8. Response sent to client with activation details

High Availability

  • Multi-region deployment
  • Automatic failover
  • 99.99% uptime SLA
  • Real-time monitoring
  • Incident response team

Best Practices

When to Use Infinity Mode

  • High-Frequency Operations: Smart contracts with constant activity
  • Production Systems: Critical applications needing guaranteed energy
  • Cost Predictability: When fixed costs are preferred
  • Convenience: Eliminate manual cycle management

Before Enabling

  1. Calculate Usage: Estimate daily energy needs
  2. Compare Costs: Infinity vs. standard cycles
  3. Fund Account: Ensure sufficient balance
  4. Test First: Try standard mode initially

After Enabling

  1. Monitor Usage: Track energy consumption patterns
  2. Set Alerts: Configure low balance notifications
  3. Review Billing: Check invoices regularly
  4. Optimize: Adjust based on actual usage

Cost Optimization

  • Annual Plans: Maximum discount for long-term commitment
  • Multiple Addresses: Bundle for volume discounts
  • Off-Peak Usage: Some operations can be scheduled
  • Regular Review: Disable for inactive addresses

Troubleshooting

Common Issues

"Address not found in Host Mode"

Problem: Address must be in Host Mode before enabling infinity

Solutions:

  • Add address using /time/add endpoint first
  • Verify address is active with /time/status
  • Check correct API key is being used

"Insufficient balance for infinity mode"

Problem: Account balance too low for activation

Solutions:

  • Add funds to account (minimum 10x daily rate)
  • Check current balance in dashboard
  • Consider weekly/monthly billing for lower minimum
  • Contact support for payment arrangements

"Already in infinity mode"

Problem: Trying to enable infinity mode twice

Solutions:

  • Check current status with /time/status
  • No action needed if already active
  • Use /time/stop to pause if needed
  • Contact support to modify settings

"Permission denied"

Problem: Account doesn't have infinity mode access

Solutions:

  • Upgrade to premium account tier
  • Contact support to enable feature
  • Check account permissions in dashboard
  • Verify using correct API key

Performance Issues

Slow Activation

Symptoms: Infinity mode takes long to activate

Solutions:

  • Check TRON network congestion
  • Verify blockchain transaction status
  • Retry if timeout occurs
  • Contact support if persists

Energy Not Delegating

Symptoms: Infinity mode active but no energy received

Solutions:

  • Wait for next delegation cycle (up to 24 hours)
  • Check address has sufficient bandwidth
  • Verify no blockchain issues
  • Contact support with transaction details

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. Dashboard: Review account settings and logs
  4. Support Ticket: Submit ticket with full details
  5. Emergency: Use priority support for infinity mode accounts

Notes

  • Prerequisites: Address must be in Host Mode via /time/add first
  • Immediate Activation: Infinity mode starts immediately upon success
  • No Partial Mode: Address is either in standard or infinity mode, not both
  • Cancellation: Use /time/stop to pause or /time/delete to remove completely
  • Refunds: Unused daily balance not refunded if cancelled mid-cycle
  • Upgrade Path: Can upgrade from standard to infinity mode anytime
  • Downgrade: Can return to standard mode after current billing cycle
  • Multiple Addresses: Each address requires separate infinity mode activation
  • API Versioning: This is v2 API; v1 does not support infinity mode
  • Maintenance: Infinity mode continues during maintenance windows
  • SLA Guarantee: 99.99% uptime for infinity mode addresses
  • Priority Support: Infinity mode accounts get priority support queue
  • Bulk Activation: Contact support for bulk infinity mode activation
  • Enterprise Plans: Custom rates available for high-volume users
  • Monitoring: Real-time usage dashboard available for infinity mode accounts