Get started with SmartCheapIP API in minutes. This guide walks you through making your first API call.

Step 1: Get Your API Key

Before making API calls, you need a valid apikey.

1. Contact Sales for an API key.
   WhatsAPP WhatsAPP
   Telegram Telegram
2. Keep this key secure, as it will be used for authentication in all API requests.

Step 2: Initialize the Client

Use your obtained apikey to initialize the SDK client. Here's the simplest example:

// Basic configuration
const config = {
    apiKey: "your_apikey_here", // Replace with your real API key
    baseUrl: "http://smartcheapip.com/api/v1/"
};

// Initialize client
const client = new ProxyClient(config);

Step 3: Call Core API

After initialization, you can start calling APIs immediately. We recommend starting with creating a flow account:

// Create a US flow account online time for 60 minutes
try {
    const account = await client.createAccount("US", 60);
    console.log("Success!", account);
    console.log(`Proxy Address: ${account.proxy_ip}:${account.http_port}`);
} catch (error) {
    console.error("Failed:", error.message);
}

If everything works, you'll receive complete flow account information including proxy server address, port, and password.

1. Create Flow Line

Create a flow line with specified country and TTL.

Request Parameters:

Request Example:

//golang
accounts, err := client.CreateAccount("US", 60)

Response Example:

{
    "code": 0,
    "data": [
        {
            "account_id": 123456,
            "account": "Account123456",
            "proxy_ip": "192.168.1.100",
            "s5_port": 1080,
            "http_port": 8080,
            "password": "secure_password_123",
            "country": "US",
            "ttl": 60,
            "traffic_used": 0
        }
    ]
}

2. Get Account List

Get the list of created flow lines, supports filtering by country and pagination.

Request Parameters:

Request Example:

//golang
// Get all accounts
accounts, err := client.GetAccountList("", 0, 10)

// Get US accounts, page 2, 20 items per page
accounts, err := client.GetAccountList("US", 20, 20)

Response Example:

{
    "code": 0,
    "data": [
        {
            "account_id": 123456,
            "account": "Account123456",
            "proxy_ip": "192.168.1.100",
            "s5_port": 1080,
            "http_port": 8080,
            "password": "secure_password_123",
            "country": "US",
            "ttl": 60,
            "traffic_used": 1024
        },
        {
            "account_id": 123457,
            "account": "Account23456",
            "proxy_ip": "192.168.1.101",
            "s5_port": 1081,
            "http_port": 8081,
            "password": "secure_password_456",
            "country": "UK",
            "ttl": 120,
            "traffic_used": 2048
        }
    ]
}

Overview

This document details how to use HTTP and SOCKS5 proxies created through the SmartCheapIP service.

Proxy Connection Information

After creating a proxy account, you will receive information including proxy server address, ports, and credentials:

{
    "account_id": 123456,
    "account": "Account12345",
    "proxy_ip": "45.76.189.214",
    "s5_port": 1080,
    "http_port": 8080,
    "password": "secure_password_123",
    "country": "US",
    "ttl": 60
}

Proxy Server URL Format:

• HTTP Proxy: http://username:password@proxyIP:HTTPport
• SOCKS5 Proxy: socks5://username:password@proxyIP:SOCKS5port

Example:

HTTP Proxy:  http://Account12345:secure_password_123@45.76.189.214:8080
SOCKS5 Proxy: socks5://Account12345:secure_password_123@45.76.189.214:1080

Using Session to Fix IP

If you need to use the same IP address for a period of time, you can use Session. Append an underscore and session name to the account name to continue using the IP obtained with that session.

Example:

HTTP Proxy:  http://Account12345_mysession:secure_password_123@45.76.189.214:8080
SOCKS5 Proxy: socks5://Account12345_mysession:secure_password_123@45.76.189.214:1080

Language/Tool Examples

import requests

# Proxy configuration
proxy_ip = "45.76.189.214"
http_port = 8080
username = "proxy_user_001"
password = "secure_password_123"

# Build proxy URL
http_proxy = f"http://{username}:{password}@{proxy_ip}:{http_port}"

proxies = {
    'http': http_proxy,
    'https': http_proxy
}

try:
    # Test proxy connection
    response = requests.get(
        'https://httpbin.org/ip',
        proxies=proxies,
        timeout=30
    )
    
    if response.status_code == 200:
        print("✅ Proxy connection successful!")
        print(f"Current IP: {response.json()['origin']}")
    else:
        print(f"❌ Request failed, status code: {response.status_code}")
        
except requests.exceptions.RequestException as e:
    print(f"❌ Proxy connection error: {e}")

<?php
function testHttpProxy($proxyIp, $httpPort, $username, $password) {
    $proxyUrl = "http://{$username}:{$password}@{$proxyIp}:{$httpPort}";
    
    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => "https://httpbin.org/ip",
        CURLOPT_PROXY => $proxyUrl,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_SSL_VERIFYPEER => false,
        CURLOPT_USERAGENT => 'Mozilla/5.0'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $error = curl_error($ch);
    curl_close($ch);
    
    if ($error) {
        echo "❌ cURL error: " . $error . "\n";
        return false;
    }
    
    if ($httpCode === 200) {
        $data = json_decode($response, true);
        echo "✅ HTTP proxy connection successful!\n";
        echo "Current IP: " . $data['origin'] . "\n";
        return $data;
    } else {
        echo "❌ HTTP request failed, status code: " . $httpCode . "\n";
        return false;
    }
}

// Usage example
testHttpProxy('45.76.189.214', 8080, 'proxy_user_001', 'secure_password_123');
?>

<?php
function useSocks5Proxy($proxyIp, $socks5Port, $username, $password) {
    if (!extension_loaded('socks5')) {
        echo "❌ Please install socks5 extension first: pecl install socks5\n";
        return false;
    }
    
    $context = stream_context_create([
        'socks5' => [
            'proxy' => "tcp://{$proxyIp}:{$socks5Port}",
            'username' => $username,
            'password' => $password,
            'timeout' => 30
        ]
    ]);
    
    try {
        $response = file_get_contents('https://httpbin.org/ip', false, $context);
        $data = json_decode($response, true);
        
        echo "✅ SOCKS5 proxy connection successful!\n";
        echo "Current IP: " . $data['origin'] . "\n";
        return $data;
    } catch (Exception $e) {
        echo "❌ SOCKS5 proxy connection failed: " . $e->getMessage() . "\n";
        return false;
    }
}

// Usage example
useSocks5Proxy('45.76.189.214', 1080, 'proxy_user_001', 'secure_password_123');
?>

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

// Proxy configuration
const proxyConfig = {
    host: '45.76.189.214',
    port: 8080,
    auth: { 
        username: 'proxy_user_001', 
        password: 'secure_password_123' 
    }
};

const agent = new HttpsProxyAgent(
    `http://${proxyConfig.auth.username}:${proxyConfig.auth.password}@${proxyConfig.host}:${proxyConfig.port}`
);

async function testHttpProxy() {
    try {
        const response = await axios.get('https://httpbin.org/ip', {
            httpsAgent: agent,
            timeout: 30000
        });
        console.log('✅ HTTP proxy connection successful!');
        console.log('Current IP:', response.data.origin);
    } catch (error) {
        console.error('❌ HTTP proxy connection failed:', error.message);
    }
}

testHttpProxy();

const axios = require('axios');
const SocksProxyAgent = require('socks-proxy-agent');

// SOCKS5 proxy configuration
const socksProxy = `socks5://proxy_user_001:secure_password_123@45.76.189.214:1080`;
const agent = new SocksProxyAgent(socksProxy);

async function testSocks5Proxy() {
    try {
        const response = await axios.get('https://httpbin.org/ip', {
            httpsAgent: agent,
            timeout: 30000
        });
        console.log('✅ SOCKS5 proxy connection successful!');
        console.log('Current IP:', response.data.origin);
    } catch (error) {
        console.error('❌ SOCKS5 proxy connection failed:', error.message);
    }
}

testSocks5Proxy();

import java.net.*;
import java.net.http.*;
import java.time.Duration;
import java.util.Base64;

public class HttpProxyExample {
    public static void main(String[] args) {
        String proxyHost = "45.76.189.214";
        int proxyPort = 8080;
        String username = "proxy_user_001";
        String password = "secure_password_123";
        
        // Create proxy
        Proxy proxy = new Proxy(Proxy.Type.HTTP, 
            new InetSocketAddress(proxyHost, proxyPort));
        
        // Create HTTP client
        HttpClient client = HttpClient.newBuilder()
            .proxy(ProxySelector.of(new InetSocketAddress(proxyHost, proxyPort)))
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        
        // Create authentication header
        String auth = username + ":" + password;
        String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes());
        
        // Create request
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/ip"))
            .header("Proxy-Authorization", "Basic " + encodedAuth)
            .timeout(Duration.ofSeconds(30))
            .build();
        
        try {
            HttpResponse<String> response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
            
            System.out.println("✅ HTTP proxy connection successful!");
            System.out.println("Response: " + response.body());
        } catch (Exception e) {
            System.err.println("❌ HTTP proxy connection failed: " + e.getMessage());
        }
    }
}

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "time"
)

func main() {
    proxyURL, _ := url.Parse("http://proxy_user_001:secure_password_123@45.76.189.214:8080")
    
    client := &http.Client{
        Timeout: 30 * time.Second,
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }
    
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        fmt.Printf("❌ HTTP proxy connection failed: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Println("✅ HTTP proxy connection successful!")
    // Process response...
}

package main

import (
    "fmt"
    "net"
    "net/http"
    "time"
    "golang.org/x/net/proxy"
)

func main() {
    // Create SOCKS5 dialer
    dialer, err := proxy.SOCKS5("tcp", "45.76.189.214:1080",
        &proxy.Auth{
            User:     "proxy_user_001",
            Password: "secure_password_123",
        },
        &net.Dialer{
            Timeout:   30 * time.Second,
            KeepAlive: 30 * time.Second,
        },
    )
    
    if err != nil {
        fmt.Printf("❌ SOCKS5 proxy creation failed: %v\n", err)
        return
    }
    
    client := &http.Client{
        Timeout: 30 * time.Second,
        Transport: &http.Transport{
            Dial: dialer.Dial,
        },
    }
    
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        fmt.Printf("❌ SOCKS5 proxy connection failed: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Println("✅ SOCKS5 proxy connection successful!")
}

# Using HTTP proxy
curl -x "http://proxy_user_001:secure_password_123@45.76.189.214:8080" \
     "https://httpbin.org/ip" -p

# Or using environment variables
export http_proxy="http://proxy_user_001:secure_password_123@45.76.189.214:8080"
export https_proxy="http://proxy_user_001:secure_password_123@45.76.189.214:8080"
curl "https://httpbin.org/ip"

# Using SOCKS5 proxy (requires curl with SOCKS support)
curl -x "socks5://proxy_user_001:secure_password_123@45.76.189.214:1080" \
     "https://httpbin.org/ip"

Frequently Asked Questions

# Test current IP
curl -x http://username:password@proxyIP:port http://httpbin.org/ip
curl -x http://username:password@proxyIP:port https://api.ipify.org?format=json

Success Response

{
    "code": 0,
    "data": { ... },
    "msg": "success"
}

Error Response

{
    "code": -1,
    "data": null,
    "msg": "Error description"
}

Response Code Explanation

A response code of 0 indicates success, all others indicate failure. Specific error information can be obtained from the msg field.

1. API Key Security: Please keep your API Key secure and avoid leaking it to unauthorized third parties.
2. Request Frequency: It is recommended to control request frequency to avoid triggering rate limiting mechanisms.
3. Error Handling: It is recommended to implement exception catching and error handling for all API calls to ensure program robustness.
4. Timeout Settings: Set appropriate timeout values based on network conditions, recommended 10-30 seconds.
5. Proxy Usage: Please keep the created flow line information secure and avoid leakage. It is recommended to change proxy passwords regularly.
6. Traffic Monitoring: Regularly check traffic usage to avoid service disruption due to traffic exhaustion.
7. Version Compatibility: Please note the API version, as incompatible changes may exist between different versions.

1. Download Go Dependencies

Before using the SmartCheapIP Go client, dowload the dependencies. click to download

2. Initialize Client

package main

import (
    "fmt"
    "log"
    "time"
    
    "proxyclient-go/client"
)

func main() {
    // Create client configuration
    config := client.Config{
        APIKey:  "your_api_key_here",
        Timeout: 30 * time.Second,
    }

    // Create API client
    apiClient, err := client.NewClient(config)
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }
    
    // Usage examples
    runExamples(apiClient)
}

3. Complete Usage Example

func runExamples(client *client.Client) {
    fmt.Println("=== ProxyClient API Usage Example ===")
    
    // Example 1: Create flow line
    fmt.Println("\n1. Creating flow line...")
    accounts, err := client.CreateAccount("US", 60)
    if err != nil {
        fmt.Printf("Failed to create account: %v\n", err)
    } else {
        fmt.Printf("Successfully created %d accounts:\n", len(accounts))
        for _, account := range accounts {
            fmt.Printf("  - Account: %s, Proxy: %s:%d, Country: %s\n", 
                account.Account, account.ProxyServer, account.HttpPort, account.Country)
        }
    }
    
    // Example 2: Get account list
    fmt.Println("\n2. Getting account list...")
    accountList, err := client.GetAccountList("US", 0, 10)
    if err != nil {
        fmt.Printf("Failed to get account list: %v\n", err)
    } else {
        fmt.Printf("Got %d accounts:\n", len(accountList))
        for _, account := range accountList {
            fmt.Printf("  - ID: %d, Account: %s, Traffic used: %d\n", 
                account.AccountId, account.Account, account.TrafficUsed)
        }
    }
    
    // Example 3: Get package info
    fmt.Println("\n3. Getting package info...")
    packageInfo, err := client.GetPackageInfo()
    if err != nil {
        fmt.Printf("Failed to get package info: %v\n", err)
    } else {
        fmt.Printf("Total traffic: %d %s\n", packageInfo.TrafficTotal, packageInfo.Unit)
        fmt.Printf("Used: %d %s\n", packageInfo.TrafficUsed, packageInfo.Unit)
        fmt.Printf("Remaining traffic: %d %s\n", packageInfo.TrafficRemain, packageInfo.Unit)
        fmt.Printf("Account count: %d\n", packageInfo.FlowAccountCount)
    }
    
    // Example 4: Query traffic details
    fmt.Println("\n4. Querying traffic details...")
    trafficDetails, err := client.GetTrafficDetail(
        "", // Query all accounts
        "2024-01-01 00:00:00", 
        "2024-01-31 23:59:59",
    )
    if err != nil {
        fmt.Printf("Failed to query traffic details: %v\n", err)
    } else {
        fmt.Printf("Found %d traffic records:\n", len(trafficDetails))
        for i, detail := range trafficDetails {
            if i >= 3 { // Only show first 3
                break
            }
            fmt.Printf("  - Date: %s, Account: %s, Traffic: %d\n", 
                detail.Date, detail.Account, detail.Traffic)
        }
    }
}

1. download Python SDK

Before using the SmartCheapIP Python client, you need to download the SDK first. click to download

2. Initialize Client

from proxy_api import *

api = Api(apikey='your_apikey_here')

3. Complete Usage Example

import time
from datetime import datetime, timedelta
from proxy_api import *

class ProxyClientManager:
    """ProxyClient Proxy Management Class"""
    
    def __init__(self, api_key):
        self.api = Api(apikey=api_key)
        self.accounts = []
        
    def create_multiple_accounts(self, countries, ttl=60):
        """Batch create flow lines for multiple countries"""
        created_accounts = []
        
        for country in countries:
            try:
                print(f"Creating {country} flow line...")
                account = self.api.create_account(country, ttl)
                
                if account:
                    created_accounts.append(account)
                    print(f"✅ {country} proxy created successfully")
                    
                    # Avoid too frequent requests
                    time.sleep(1)
                    
            except Exception as e:
                print(f"❌ Failed to create {country} proxy: {e}")
                
        self.accounts.extend(created_accounts)
        return created_accounts
    
    def list_all_accounts(self):
        """List all accounts with statistics"""
        try:
            accounts = self.api.get_account_list()
            
            if isinstance(accounts, list):
                # Statistics by country
                country_stats = {}
                for account in accounts:
                    country = account.get('country', 'Unknown')
                    country_stats[country] = country_stats.get(country, 0) + 1
                
                print(f"📊 Account statistics:")
                for country, count in country_stats.items():
                    print(f"  {country}: {count} accounts")
                    
                return accounts
            else:
                print("❌ Failed to get account list")
                return []
                
        except Exception as e:
            print(f"❌ Failed to get account list: {e}")
            return []
    
    def monitor_traffic_usage(self):
        """Monitor traffic usage"""
        try:
            # Get package information
            package_info = self.api.get_package_info()
            
            if isinstance(package_info, dict):
                total = package_info.get('traffic_total', 0)
                used = package_info.get('traffic_used', 0)
                remain = package_info.get('traffic_remain', 0)
                
                usage_percent = (used / total * 100) if total > 0 else 0
                
                print(f"📈 Traffic usage:")
                print(f"  Total traffic: {total} {package_info.get('unit', '')}")
                print(f"  Used: {used} ({usage_percent:.1f}%)")
                print(f"  Remaining traffic: {remain}")
                
                # Traffic warning
                if usage_percent > 80:
                    print("⚠️  Warning: Traffic usage exceeds 80%!")
                elif usage_percent > 95:
                    print("🚨 Emergency: Traffic almost exhausted!")
                    
            return package_info
            
        except Exception as e:
            print(f"❌ Failed to get traffic information: {e}")
            return None

1. download PHP SDK

Before using the SmartCheapIP PHP client, you need to download the SDK first. click to download

2. Initialize Client

require_once 'proxy_client.php';

// Configure client
$config = new  Config();
$config->apiKey = "your_apikey_here";
$config->timeout = 30;

// Create client
$client = new ProxyClient($config);

3. Complete Usage Example

require_once 'proxy_client.php';

// Configure client
$config = new  Config();
$config->apiKey = "your_apikey_here";
$config->timeout = 30;

try {
    // Create client
    $client = new ProxyClient($config);

    echo "=== Create Flow Line ===\n";
    $accounts = $client->createAccount("US", 60);
    echo "Created successfully, account count: " . count($accounts) . "\n";
    foreach ($accounts as $account) {
        echo "Account: " . $account->account . ", Country: " . $account->country . "\n";
    }

    echo "\n=== Get Flow Line List ===\n";
    $accountList = $client->getAccountList("US", 0, 10);
    echo "Got " . count($accountList) . " accounts\n";
    foreach ($accountList as $account) {
        echo "Account ID: " . $account->account_id . ", Account: " . $account->account . 
             ", Proxy IP: " . $account->proxy_ip . ", Port: " . $account->s5_port . "\n";
    }

    echo "\n=== Get Package Info ===\n";
    $packageInfo = $client->getPackageInfo();
    echo "Total traffic: " . $packageInfo->traffic_total . $packageInfo->unit . "\n";
    echo "Used: " . $packageInfo->traffic_used . $packageInfo->unit . "\n";
    echo "Remaining traffic: " . $packageInfo->traffic_remain . $packageInfo->unit . "\n";
    echo "Account count: " . $packageInfo->flow_account_count . "\n";

    echo "\n=== Query Traffic Details ===\n";
    $trafficDetails = $client->getTrafficDetail(
        "", // Empty string means query all accounts
        "2025-11-01 00:00:00",
        "2025-11-30 23:59:59"
    );
    echo "Found " . count($trafficDetails) . " traffic records\n";
    foreach ($trafficDetails as $detail) {
        echo "Date: " . $detail->date . ", Account: " . $detail->account . 
             ", Traffic: " . $detail->traffic . "\n";
    }

    echo "\n=== Remove Flow Line ===\n";
    try {
        $result = $client->removeAccount("Account153300");
        echo "Delete result: " . ($result ? "Success" : "Failed") . "\n";
    } catch (ApiException $e) {
        echo "Delete failed: " . $e->getMessage() . "\n";
    }

} catch (ApiException $e) {
    echo "API Error [" . $e->getErrorCode() . "]: " . $e->getMessage() . "\n";
} catch (Exception $e) {
    echo "System Error: " . $e->getMessage() . "\n";
}

4. Error Handling Example

try{
    // API call code
} catch (ApiException $e) {
    echo "API Error [" . $e->getErrorCode() . "]: " . $e->getMessage() . "\n";
} catch (Exception $e) {
    echo "System Error: " . $e->getMessage() . "\n";
}

1. Download Java SDK

Before using the SmartCheapIP Java client, you need to download the Java SDK. click to download

2. Initialize Client

package com.proxyclient.client.example;

import com.proxyclient.client.ProxyClient;
import com.proxyclient.client.ApiException;
import com.proxyclient.client.model.FlowAccountInfo;
import com.proxyclient.client.model.PackageInfo;
import com.proxyclient.client.model.FlowDetailInfo;


// Configure client
ProxyClient.Config config = new ProxyClient.Config("your_apikey_here")
                .setTimeout(30000);

// Create client
ProxyClient client = new ProxyClient(config);

3. Complete Usage Example

package com.proxyclient.client.example;

import com.proxyclient.client.ProxyClient;
import com.proxyclient.client.ApiException;
import com.proxyclient.client.model.FlowAccountInfo;
import com.proxyclient.client.model.PackageInfo;
import com.proxyclient.client.model.FlowDetailInfo;
import java.util.List;

public class ExampleUsage {
    public static void main(String[] args) {
        // Configure client
        ProxyClient.Config config = new ProxyClient.Config("your_apikey_here")
                .setTimeout(30000);
        
        try {
            // Create client
            ProxyClient client = new ProxyClient(config);
            
            System.out.println("=== ProxyClient Java Client Examples ===");
            
            // Example 1: Create flow line
            System.out.println("\n1. Creating flow line...");
            try {
                List<FlowAccountInfo> accounts = client.createAccount("US", 60);
                System.out.println("Created successfully, account count: " + accounts.size());
                for (FlowAccountInfo account : accounts) {
                    System.out.println("Account: " + account.getAccount() + 
                                     ", Country: " + account.getCountry() +
                                     ", Proxy IP: " + account.getProxyIp() + ":" + account.getS5Port());
                }
            } catch (ApiException e) {
                System.out.println("Failed to create account: " + e.getMessage());
            }
            
            // Example 2: Get flow line list
            System.out.println("\n2. Getting flow line list...");
            try {
                List<FlowAccountInfo> accountList = client.getAccountList("US", 0, 10);
                System.out.println("Got " + accountList.size() + " accounts");
                for (FlowAccountInfo account : accountList) {
                    System.out.println("Account ID: " + account.getAccountId() + 
                                     ", Account: " + account.getAccount() + 
                                     ", Country: " + account.getCountry());
                }
            } catch (ApiException e) {
                System.out.println("Failed to get account list: " + e.getMessage());
            }
            
            // Example 3: Get package info
            System.out.println("\n3. Getting package info...");
            try {
                PackageInfo packageInfo = client.getPackageInfo();
                System.out.println("Total traffic: " + packageInfo.getTrafficTotal() + " " + packageInfo.getUnit());
                System.out.println("Used: " + packageInfo.getTrafficUsed() + " " + packageInfo.getUnit());
                System.out.println("Remaining traffic: " + packageInfo.getTrafficRemain() + " " + packageInfo.getUnit());
                System.out.println("Account count: " + packageInfo.getFlowAccountCount());
            } catch (ApiException e) {
                System.out.println("Failed to get package info: " + e.getMessage());
            }
            
            // Example 4: Query traffic details
            System.out.println("\n4. Querying traffic details...");
            try {
                List<FlowDetailInfo> trafficDetails = client.getTrafficDetail(
                    "", // Empty string means query all accounts
                    "2025-11-01 00:00:00",
                    "2025-11-30 23:59:59"
                );
                System.out.println("Found " + trafficDetails.size() + " traffic records");
                for (int i = 0; i < Math.min(trafficDetails.size(), 3); i++) { // Only show first 3
                    FlowDetailInfo detail = trafficDetails.get(i);
                    System.out.println("Date: " + detail.getDate() + 
                                     ", Account: " + detail.getAccount() + 
                                     ", Traffic: " + detail.getTraffic());
                }
            } catch (ApiException e) {
                System.out.println("Failed to query traffic details: " + e.getMessage());
            }
            

            System.out.println("\n=== Example execution completed ===");
            
        } catch (ApiException e) {
            System.err.println("Client initialization failed: " . e.getMessage());
        }
    }
}

4. Error Handling Example

try{
    // API call code
} catch (ApiException e) {
    System.out.println(e.getMessage());
}

1. download Node.js SDK

Before using the SmartCheapIP Node.js client, you need to download the SDK first. click to download

2. Initialize Client

const { ProxyClient, Config, ApiError } = require('../src');


// Configure client
const config = new Config({
        apiKey: "your_apikey_here",
        timeout: 30000
    });

// Create client
const client = new ProxyClient(config);

3. Complete Usage Example

const { ProxyClient, Config, ApiError } = require('../src');

/**
 * Usage Example
 */
async function main() {
    // Configure client
    const config = new Config({
        apiKey: "your_apikey_here",
        timeout: 30000
    });

    try {
        // Create client
        const client = new ProxyClient(config);

        console.log("=== ProxyClient Node.js Client Examples ===");

        // Example 1: Create flow line
        console.log("\n1. Creating flow line...");
        try {
            const accounts = await client.createAccount("US", 60);
            console.log(`Created successfully, account count: ${accounts.length}`);
            accounts.forEach(account => {
                console.log(`Account: ${account.account}, Country: ${account.country}, Proxy IP: ${account.proxy_ip}:${account.s5_port}`);
            });
        } catch (error) {
            console.log(`Failed to create account: ${error.message}`);
        }

        // Example 2: Get flow line list
        console.log("\n2. Getting flow line list...");
        try {
            const accountList = await client.getAccountList("US", 0, 10);
            console.log(`Got ${accountList.length} accounts`);
            accountList.forEach(account => {
                console.log(`Account ID: ${account.account_id}, Account: ${account.account}, Country: ${account.country}`);
            });
        } catch (error) {
            console.log(`Failed to get account list: ${error.message}`);
        }

        // Example 3: Get package info
        console.log("\n3. Getting package info...");
        try {
            const packageInfo = await client.getPackageInfo();
            console.log(`Total traffic: ${packageInfo.traffic_total} ${packageInfo.unit}`);
            console.log(`Used: ${packageInfo.traffic_used} ${packageInfo.unit}`);
            console.log(`Remaining traffic: ${packageInfo.traffic_remain} ${packageInfo.unit}`);
            console.log(`Account count: ${packageInfo.flow_account_count}`);
        } catch (error) {
            console.log(`Failed to get package info: ${error.message}`);
        }

        // Example 4: Query traffic details
        console.log("\n4. Querying traffic details...");
        try {
            const trafficDetails = await client.getTrafficDetail(
                "", // Empty string means query all accounts
                "2025-11-01 00:00:00",
                "2025-11-30 23:59:59"
            );
            console.log(`Found ${trafficDetails.length} traffic records`);
            trafficDetails.slice(0, 3).forEach(detail => { // Only show first 3
                console.log(`Date: ${detail.date}, Account: ${detail.account}, Traffic: ${detail.traffic}`);
            });
        } catch (error) {
            console.log(`Failed to query traffic details: ${error.message}`);
        }

        // Example 5: Remove flow line
        console.log("\n5. Removing flow line...");
        try {
            const result = await client.removeAccount("test_account_123");
            console.log(`Delete result: ${result ? "Success" : "Failed"}`);
        } catch (error) {
            console.log(`Failed to delete account: ${error.message}`);
        }

    } catch (error) {
        if (error instanceof ApiError) {
            console.error(`API Error [${error.code}]: ${error.message}`);
        } else {
            console.error(`System Error: ${error.message}`);
        }
    }
}

/**
 * Error Handling Example
 */
async function handleApiError() {
    const config = new Config({
        apiKey: "invalid_key", // Test error handling with invalid API key
    });

    try {
        const client = new ProxyClient(config);
        await client.getPackageInfo();
    } catch (error) {
        if (error instanceof ApiError) {
            console.log(`API Business Error: code=${error.code}, message=${error.message}`);
        } else {
            console.log(`Network or other error: ${error.message}`);
        }
    }
}

// Run example
if (require.main === module) {
    main().catch(console.error);
}

module.exports = {
    main,
    handleApiError
};

4. Error Handling Example

try {
        const client = new ProxyClient(config);
    } catch (error) {
        if (error instanceof ApiError) {
            console.log(`API Business Error: code=${error.code}, message=${error.message}`);
        } else {
            console.log(`Network or other error: ${error.message}`);
        }
    }