Quick Start Guide

Follow these simple steps to start using ProxyOmega proxies in your applications.

Step 1: Get Your Credentials

Log in to your ProxyOmega dashboard to find your username and password. These credentials will be used for proxy authentication.

Step 2: Choose Your Proxy Type

Step 3: Configure Your Application

Here's a basic example using cURL:

# Basic proxy request
curl -x http://username:[email protected]:10000 https://example.com

# With country targeting
curl -x http://username-country_US:[email protected]:10000 https://example.com

Authentication

ProxyOmega supports multiple authentication methods to secure your proxy connections.

Username/Password Authentication

The most common authentication method. Use your ProxyOmega credentials in the proxy URL:

http://username:password@proxy-server:port

IP Whitelist Authentication

For enhanced security, you can whitelist specific IP addresses that are allowed to use your proxies without credentials.

Session Management

Control session persistence using username parameters:

Proxy Endpoints

Connect to our proxy network using your dashboard credentials. Username format: emailprefix_userid

Username Parameters

Customize proxy behavior using username parameters:

API Reference

Manage your ProxyOmega account programmatically with our RESTful API.

Base URL

https://api.proxyomega.com/v1

Authentication

Include your API key in the Authorization header:

curl -H "Authorization: Bearer YOUR_API_KEY" https://api.proxyomega.com/v1/account

Response Format

All API responses are returned in JSON format:

{
  "success": true,
  "data": {
    // Response data
  },
  "timestamp": "2024-06-13T12:00:00Z"
}

Error Handling

Error responses include helpful information for debugging:

{
  "success": false,
  "error": {
    "code": "INVALID_API_KEY",
    "message": "The provided API key is invalid",
    "details": {}
  }
}

Residential Proxies

Access our premium residential proxy networks with both unlimited and pay-as-you-go options.

Proxy Generator Configuration

# 5 threads subscription (ports 10000-10004)
curl -x http://john_123:[email protected]:10000 https://example.com
curl -x http://john_123:[email protected]:10001 https://example.com

# 25 threads subscription (ports 10000-10024)
curl -x http://john_123:[email protected]:10024 https://example.com

# 100 threads subscription (ports 10000-10099)
curl -x http://john_123:[email protected]:10099 https://example.com

# Random location
curl -x http://john_123:[email protected]:20228 https://example.com

# Country targeting
curl -x http://john_123-country-us:[email protected]:20228 https://example.com

# State targeting
curl -x http://john_123-country-us-state-ca:[email protected]:20228 https://example.com

# City targeting
curl -x http://john_123-city-newyork:[email protected]:20228 https://example.com

# Sticky session with TTL (30 minutes)
curl -x http://john_123-session-abc123-ttl-30:[email protected]:20228 https://example.com

Advanced Usage

# Unlimited - Sticky session (maintains IP across requests)
curl -x http://john_123-session-order123:[email protected]:10000 https://example.com

# Platinum - Session with custom TTL (time-to-live in minutes)
curl -x http://john_123-session-cart456-ttl-60:[email protected]:20228 https://example.com

# Force new IP on each request (no session parameter)
curl -x http://john_123:[email protected]:10000 https://example.com

Mobile Proxies

Premium 3G/4G/5G mobile IPs from real carrier networks with the highest trust scores.

Proxy Generator Configuration

Connection Examples

# Basic mobile proxy connection
curl -x http://john_123:[email protected]:20229 https://example.com

# With country targeting
curl -x http://john_123-country-us:[email protected]:20229 https://example.com

# With state targeting
curl -x http://john_123-country-us-state-tx:[email protected]:20229 https://example.com

# Carrier targeting (US carriers)
curl -x http://john_123-country-us-carrier-verizon:[email protected]:20229 https://example.com
curl -x http://john_123-country-us-carrier-att:[email protected]:20229 https://example.com
curl -x http://john_123-country-us-carrier-tmobile:[email protected]:20229 https://example.com

# City targeting
curl -x http://john_123-city-london:[email protected]:20229 https://example.com

# Session with custom TTL (keep same IP for 30 minutes)
curl -x http://john_123-session-mobile123-ttl-30:[email protected]:20229 https://example.com

# Multiple parameters combined
curl -x http://john_123-country-us-state-ca-city-losangeles-session-app1:[email protected]:20229 https://example.com

Why Mobile Proxies?

ISP Static Proxies

Ultra-fast datacenter IPs with residential classification, perfect for speed-critical applications.

Proxy Configuration

Connection Examples

# Example ISP package credentials (ports vary by package):
45.123.45.67:3128:user123:pass456
45.123.45.68:8888:user123:pass456
45.123.45.69:12345:user123:pass456
45.123.45.70:55443:user123:pass456
45.123.45.71:9999:user123:pass456

# HTTP/HTTPS connection
curl -x http://user123:[email protected]:3128 https://example.com

# SOCKS5 connection (same IP, may use same or different port)
curl -x socks5://user123:[email protected]:3128 https://example.com

# With IP whitelist (no auth needed)
curl -x http://45.123.45.67:3128 https://example.com

# Multiple concurrent connections (different IPs)
curl -x http://user123:[email protected]:3128 https://example.com &
curl -x http://user123:[email protected]:8888 https://example.com &
curl -x http://user123:[email protected]:12345 https://example.com &

Optimized Use Cases

IPv6 Network

Access the world's largest proxy pool with over 70 octillion unique IPv6 addresses.

Proxy Generator Configuration

Thread-Based Model Explained

Unlike traditional proxy services, IPv6 proxies use a unique thread-based pricing model:

Connection Examples

# Basic IPv6 connection
curl -x http://john_123:[email protected]:9000 https://example.com

# With country targeting
curl -x http://john_123-country-us:[email protected]:9000 https://example.com

# Country targeting only for IPv6
curl -x http://john_123-country-de:[email protected]:9000 https://example.com
curl -x http://john_123-country-jp:[email protected]:9000 https://example.com

# Multiple concurrent threads (all use same port!)
# Thread 1
curl -x http://john_123:[email protected]:9000 https://example1.com &

# Thread 2
curl -x http://john_123:[email protected]:9000 https://example2.com &

# Thread 3
curl -x http://john_123:[email protected]:9000 https://example3.com &

# Thread 4 with country targeting
curl -x http://john_123-country-de:[email protected]:9000 https://example4.com &

# Session persistence (maintain same IP)
curl -x http://john_123-session-worker1:[email protected]:9000 https://example.com

# Custom TTL (time-to-live)
curl -x http://john_123-ttl-10:[email protected]:9000 https://example.com

# SOCKS5 protocol (if supported)
curl -x socks5://john_123:[email protected]:9000 https://example.com

# Combined parameters (country + session)
curl -x http://john_123-country-jp-session-api1:[email protected]:9000 https://example.com

Pricing Examples

JavaScript Examples

Integration examples for Node.js and browser-based applications.

Basic Request with Axios

const axios = require('axios');

const proxy = {
  host: 'residential.proxyomega.com',
  port: 10000,
  auth: {
    username: 'your_username',
    password: 'your_password'
  }
};

axios.get('https://api.example.com/data', { proxy })
  .then(response => {
    console.log('Response:', response.data);
  })
  .catch(error => {
    console.error('Error:', error.message);
  });

Rotating Proxies

class ProxyRotator {
  constructor(username, password, portRange = [10000, 10099]) {
    this.username = username;
    this.password = password;
    this.portRange = portRange;
    this.currentPort = portRange[0];
  }

  getNextProxy() {
    const proxy = {
      host: 'residential.proxyomega.com',
      port: this.currentPort,
      auth: {
        username: this.username,
        password: this.password
      }
    };
    
    this.currentPort++;
    if (this.currentPort > this.portRange[1]) {
      this.currentPort = this.portRange[0];
    }
    
    return proxy;
  }
}

// Usage
const rotator = new ProxyRotator('username', 'password');
const proxy = rotator.getNextProxy();

Python Examples

Use ProxyOmega with Python's popular HTTP libraries.

Basic Request with Requests

import requests

proxies = {
    'http': 'http://username:[email protected]:10000',
    'https': 'http://username:[email protected]:10000'
}

response = requests.get('https://api.example.com/data', proxies=proxies)
print(response.json())

Async Requests with aiohttp

import asyncio
import aiohttp

async def fetch_with_proxy(session, url):
    proxy = 'http://username:[email protected]:10000'
    async with session.get(url, proxy=proxy) as response:
        return await response.json()

async def main():
    async with aiohttp.ClientSession() as session:
        data = await fetch_with_proxy(session, 'https://api.example.com/data')
        print(data)

asyncio.run(main())

PHP Examples

Complete examples for integrating ProxyOmega with PHP applications.

Basic cURL Request

Proxy Rotation Class

 ['host' => 'residential.proxyomega.com', 'ports' => []],
        'platinum' => ['host' => 'platinum.proxyomega.com', 'port' => 20228],
        'mobile' => ['host' => 'mobile.proxyomega.com', 'port' => 20229],
        'ipv6' => ['host' => 'ipv6.proxyomega.com', 'port' => 9000]
    ];
    private $currentPort = 0;
    
    public function __construct($email, $userId, $apiKey, $threads = 5) {
        $emailPrefix = explode('@', $email)[0];
        $this->username = $emailPrefix . '_' . $userId;
        $this->password = $apiKey;
        
        // Setup unlimited residential ports based on threads
        for ($i = 0; $i < $threads; $i++) {
            $this->endpoints['unlimited']['ports'][] = 10000 + $i;
        }
    }
    
    public function request($url, $proxyType = 'unlimited', $params = []) {
        $proxy = $this->getProxy($proxyType, $params);
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_PROXY, $proxy['host']);
        curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxy['auth']);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
        
        $response = curl_exec($ch);
        $info = curl_getinfo($ch);
        curl_close($ch);
        
        return [
            'response' => $response,
            'info' => $info,
            'proxy_used' => $proxy
        ];
    }
    
    private function getProxy($type, $params = []) {
        $username = $this->username;
        
        // Add parameters to username
        if (!empty($params['country'])) {
            $username .= '-country-' . $params['country'];
        }
        if (!empty($params['session'])) {
            $username .= '-session-' . $params['session'];
        }
        if (!empty($params['ttl'])) {
            $username .= '-ttl-' . $params['ttl'];
        }
        
        switch ($type) {
            case 'unlimited':
                $port = $this->endpoints['unlimited']['ports'][$this->currentPort];
                $this->currentPort = ($this->currentPort + 1) % count($this->endpoints['unlimited']['ports']);
                return [
                    'host' => $this->endpoints['unlimited']['host'] . ':' . $port,
                    'auth' => $username . ':' . $this->password
                ];
                
            case 'platinum':
                return [
                    'host' => $this->endpoints['platinum']['host'] . ':' . $this->endpoints['platinum']['port'],
                    'auth' => $username . ':' . $this->password
                ];
                
            case 'mobile':
                return [
                    'host' => $this->endpoints['mobile']['host'] . ':' . $this->endpoints['mobile']['port'],
                    'auth' => $username . ':' . $this->password
                ];
                
            case 'ipv6':
                return [
                    'host' => $this->endpoints['ipv6']['host'] . ':' . $this->endpoints['ipv6']['port'],
                    'auth' => $username . ':' . $this->password
                ];
                
            default:
                throw new Exception('Invalid proxy type: ' . $type);
        }
    }
}

// Usage example
$rotator = new ProxyRotator('[email protected]', 123, 'your_api_key_here', 25);

// Unlimited residential request
$result = $rotator->request('https://api.example.com/data', 'unlimited');
echo $result['response'];

// Platinum with country targeting
$result = $rotator->request('https://api.example.com/data', 'platinum', [
    'country' => 'us',
    'session' => 'order123'
]);

// Mobile with session
$result = $rotator->request('https://api.example.com/data', 'mobile', [
    'country' => 'uk',
    'ttl' => 30
]);
?>

Guzzle HTTP Client Example

 'http://john_123:[email protected]:10000',
    'timeout' => 30,
    'verify' => false // Disable SSL verification if needed
]);

try {
    // Simple GET request
    $response = $client->get('https://api.example.com/data');
    echo $response->getBody();
    
    // POST request with data
    $response = $client->post('https://api.example.com/submit', [
        'json' => [
            'name' => 'John Doe',
            'email' => '[email protected]'
        ]
    ]);
    
    echo "Status: " . $response->getStatusCode() . "\n";
    echo "Body: " . $response->getBody() . "\n";
    
} catch (RequestException $e) {
    echo "Error: " . $e->getMessage();
    if ($e->hasResponse()) {
        echo "\nResponse: " . $e->getResponse()->getBody();
    }
}

// Using different proxy types with Guzzle
$proxies = [
    'unlimited' => 'http://john_123:[email protected]:10000',
    'platinum' => 'http://john_123-country-us:[email protected]:20228',
    'mobile' => 'http://john_123-session-mob1:[email protected]:20229',
    'ipv6' => 'http://john_123:[email protected]:9000'
];

// Rotate through different proxy types
foreach ($proxies as $type => $proxy) {
    $client = new Client(['proxy' => $proxy]);
    
    try {
        $response = $client->get('https://httpbin.org/ip');
        $data = json_decode($response->getBody(), true);
        echo "$type proxy IP: " . $data['origin'] . "\n";
    } catch (Exception $e) {
        echo "$type proxy error: " . $e->getMessage() . "\n";
    }
}
?>

Concurrent Requests with Guzzle

 $url) {
    $port = 10000 + $index; // Assuming you have at least 5 threads
    
    $promises[] = $client->getAsync($url, [
        'proxy' => "http://john_123:[email protected]:$port"
    ]);
}

// Wait for all requests to complete
$responses = Promise\settle($promises)->wait();

// Process responses
foreach ($responses as $index => $response) {
    if ($response['state'] === 'fulfilled') {
        echo "Request $index succeeded: " . $response['value']->getBody() . "\n";
    } else {
        echo "Request $index failed: " . $response['reason']->getMessage() . "\n";
    }
}
?>

Go Examples

High-performance proxy integration for Go applications with connection pooling and concurrency.

Basic HTTP Request

package main

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

func main() {
    // Configure proxy
    proxyURL, err := url.Parse("http://john_123:[email protected]:10000")
    if err != nil {
        panic(err)
    }
    
    // Create HTTP client with proxy
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
        Timeout: 30 * time.Second,
    }
    
    // Make request
    resp, err := client.Get("https://api.example.com/data")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading body: %v\n", err)
        return
    }
    
    fmt.Printf("Status: %d\n", resp.StatusCode)
    fmt.Printf("Response: %s\n", string(body))
}

Proxy Manager Struct

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "strings"
    "sync"
    "time"
)

type ProxyManager struct {
    username    string
    password    string
    endpoints   map[string]ProxyEndpoint
    currentPort int
    mu          sync.Mutex
}

type ProxyEndpoint struct {
    Host  string
    Ports []int
}

func NewProxyManager(email string, userID int, apiKey string, threads int) *ProxyManager {
    emailPrefix := email[:strings.Index(email, "@")]
    username := fmt.Sprintf("%s_%d", emailPrefix, userID)
    
    // Setup unlimited residential ports
    unlimitedPorts := make([]int, threads)
    for i := 0; i < threads; i++ {
        unlimitedPorts[i] = 10000 + i
    }
    
    return &ProxyManager{
        username: username,
        password: apiKey,
        endpoints: map[string]ProxyEndpoint{
            "unlimited": {Host: "residential.proxyomega.com", Ports: unlimitedPorts},
            "platinum":  {Host: "platinum.proxyomega.com", Ports: []int{20228}},
            "mobile":    {Host: "mobile.proxyomega.com", Ports: []int{20229}},
            "ipv6":      {Host: "ipv6.proxyomega.com", Ports: []int{9000}},
        },
        currentPort: 0,
    }
}

func (pm *ProxyManager) GetClient(proxyType string, params map[string]string) (*http.Client, error) {
    proxyURL, err := pm.buildProxyURL(proxyType, params)
    if err != nil {
        return nil, err
    }
    
    return &http.Client{
        Transport: &http.Transport{
            Proxy:                 http.ProxyURL(proxyURL),
            MaxIdleConns:          100,
            IdleConnTimeout:       90 * time.Second,
            TLSHandshakeTimeout:   10 * time.Second,
            ExpectContinueTimeout: 1 * time.Second,
        },
        Timeout: 30 * time.Second,
    }, nil
}

func (pm *ProxyManager) buildProxyURL(proxyType string, params map[string]string) (*url.URL, error) {
    endpoint, ok := pm.endpoints[proxyType]
    if !ok {
        return nil, fmt.Errorf("invalid proxy type: %s", proxyType)
    }
    
    // Build username with parameters
    username := pm.username
    if country, ok := params["country"]; ok {
        username += "-country-" + country
    }
    if session, ok := params["session"]; ok {
        username += "-session-" + session
    }
    if ttl, ok := params["ttl"]; ok {
        username += "-ttl-" + ttl
    }
    
    // Get port
    var port int
    if proxyType == "unlimited" {
        pm.mu.Lock()
        port = endpoint.Ports[pm.currentPort]
        pm.currentPort = (pm.currentPort + 1) % len(endpoint.Ports)
        pm.mu.Unlock()
    } else {
        port = endpoint.Ports[0]
    }
    
    proxyURL := fmt.Sprintf("http://%s:%s@%s:%d", username, pm.password, endpoint.Host, port)
    return url.Parse(proxyURL)
}

// Usage example
func main() {
    pm := NewProxyManager("[email protected]", 123, "your_api_key", 25)
    
    // Unlimited residential request
    client, err := pm.GetClient("unlimited", nil)
    if err != nil {
        panic(err)
    }
    
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Printf("Unlimited proxy response: %s\n", string(body))
    
    // Platinum with country targeting
    client, err = pm.GetClient("platinum", map[string]string{
        "country": "us",
        "session": "test123",
    })
    if err != nil {
        panic(err)
    }
    
    resp, err = client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ = ioutil.ReadAll(resp.Body)
    fmt.Printf("Platinum proxy response: %s\n", string(body))
}

Concurrent Requests

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "sync"
    "time"
)

func makeRequest(proxyURL string, targetURL string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done()
    
    proxy, _ := url.Parse(proxyURL)
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxy),
        },
        Timeout: 30 * time.Second,
    }
    
    resp, err := client.Get(targetURL)
    if err != nil {
        results <- fmt.Sprintf("Error: %v", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    results <- fmt.Sprintf("Success: %s", string(body))
}

func main() {
    var wg sync.WaitGroup
    results := make(chan string, 10)
    
    // URLs to scrape
    urls := []string{
        "https://httpbin.org/ip",
        "https://httpbin.org/headers",
        "https://httpbin.org/user-agent",
        "https://api.example.com/data1",
        "https://api.example.com/data2",
    }
    
    // Use different proxy ports for each request
    for i, targetURL := range urls {
        wg.Add(1)
        port := 10000 + i // Assuming you have at least 5 threads
        proxyURL := fmt.Sprintf("http://john_123:[email protected]:%d", port)
        
        go makeRequest(proxyURL, targetURL, &wg, results)
    }
    
    // Start a goroutine to close results channel when all requests are done
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // Collect results
    for result := range results {
        fmt.Println(result)
    }
}

Advanced HTTP Client with Retry

package main

import (
    "context"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "time"
)

type ProxyClient struct {
    client      *http.Client
    maxRetries  int
    retryDelay  time.Duration
}

func NewProxyClient(proxyURL string, maxRetries int) (*ProxyClient, error) {
    proxy, err := url.Parse(proxyURL)
    if err != nil {
        return nil, err
    }
    
    transport := &http.Transport{
        Proxy:                 http.ProxyURL(proxy),
        MaxIdleConns:          100,
        IdleConnTimeout:       90 * time.Second,
        TLSHandshakeTimeout:   10 * time.Second,
        ExpectContinueTimeout: 1 * time.Second,
        DisableCompression:    true,
    }
    
    return &ProxyClient{
        client: &http.Client{
            Transport: transport,
            Timeout:   30 * time.Second,
        },
        maxRetries: maxRetries,
        retryDelay: 2 * time.Second,
    }, nil
}

func (pc *ProxyClient) GetWithRetry(ctx context.Context, url string) ([]byte, error) {
    var lastErr error
    
    for attempt := 0; attempt <= pc.maxRetries; attempt++ {
        if attempt > 0 {
            select {
            case <-ctx.Done():
                return nil, ctx.Err()
            case <-time.After(pc.retryDelay):
                // Continue with retry
            }
        }
        
        req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
        if err != nil {
            return nil, err
        }
        
        // Add headers
        req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
        req.Header.Set("Accept", "text/html,application/json")
        
        resp, err := pc.client.Do(req)
        if err != nil {
            lastErr = err
            fmt.Printf("Attempt %d failed: %v\n", attempt+1, err)
            continue
        }
        
        defer resp.Body.Close()
        
        if resp.StatusCode >= 500 {
            lastErr = fmt.Errorf("server error: %d", resp.StatusCode)
            fmt.Printf("Attempt %d got status %d\n", attempt+1, resp.StatusCode)
            continue
        }
        
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            lastErr = err
            continue
        }
        
        return body, nil
    }
    
    return nil, fmt.Errorf("max retries exceeded: %v", lastErr)
}

func main() {
    // Example with different proxy types
    proxies := map[string]string{
        "unlimited": "http://john_123:[email protected]:10000",
        "platinum":  "http://john_123-country-us:[email protected]:20228",
        "mobile":    "http://john_123-session-mob1:[email protected]:20229",
        "ipv6":      "http://john_123:[email protected]:9000",
    }
    
    ctx := context.Background()
    
    for proxyType, proxyURL := range proxies {
        client, err := NewProxyClient(proxyURL, 3)
        if err != nil {
            fmt.Printf("Error creating %s client: %v\n", proxyType, err)
            continue
        }
        
        body, err := client.GetWithRetry(ctx, "https://httpbin.org/ip")
        if err != nil {
            fmt.Printf("%s proxy failed: %v\n", proxyType, err)
            continue
        }
        
        fmt.Printf("%s proxy response: %s\n", proxyType, string(body))
    }
}

Best Practices

Follow these guidelines to maximize performance and reliability.

Performance Optimization

Frequently Asked Questions

Account Management API

Manage user accounts, subscriptions, and billing through our REST API.

Get User Profile

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.proxyomega.com/v1/auth/me

{
  "success": true,
  "data": {
    "user": {
      "id": 12345,
      "email": "[email protected]",
      "name": "John Doe",
      "role": "user",
      "created_at": "2024-01-15T10:30:00Z",
      "email_verified": true,
      "two_factor_enabled": false
    }
  }
}

Update Profile

curl -X PUT -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Jane Doe", "company": "ProxyUser Inc"}' \
  https://api.proxyomega.com/v1/user/profile

Get Active Subscriptions

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.proxyomega.com/v1/subscriptions/active

{
  "success": true,
  "data": {
    "subscriptions": [
      {
        "id": "sub_1234567890",
        "type": "unlimited",
        "status": "active",
        "threads": 25,
        "price": 183.20,
        "billing_cycle": "monthly",
        "current_period_end": "2024-07-15T00:00:00Z",
        "auto_renew": true
      }
    ]
  }
}

Cancel Subscription

curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.proxyomega.com/v1/subscriptions/sub_1234567890/cancel

IP Whitelist API

Manage IP whitelist for authentication-free proxy access. Each user can whitelist up to 50 IP addresses.

List Whitelisted IPs

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.proxyomega.com/v1/proxy/whitelist?type=unlimited"

{
  "success": true,
  "data": {
    "ips": [
      {
        "id": 1,
        "ip_address": "192.168.1.100",
        "label": "Office Network",
        "created_at": "2024-06-01T10:30:00Z"
      },
      {
        "id": 2,
        "ip_address": "10.0.0.50",
        "label": "Home VPN",
        "created_at": "2024-06-05T15:45:00Z"
      }
    ],
    "count": 2,
    "max": 50
  }
}

Add IP to Whitelist

curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ip_address": "203.0.113.45",
    "proxy_type": "unlimited",
    "label": "Production Server"
  }' \
  https://api.proxyomega.com/v1/proxy/whitelist/add

Remove IP from Whitelist

curl -X DELETE -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"id": 12345}' \
  https://api.proxyomega.com/v1/proxy/whitelist/remove

Usage Statistics API

Monitor your proxy usage, bandwidth consumption, and connection statistics in real-time.

Get Usage Summary

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.proxyomega.com/v1/proxy/unlimited/usage?days=7"

{
  "success": true,
  "data": {
    "usage": [
      {
        "timestamp": "2024-06-13T12:00:00Z",
        "connections": 150,
        "bandwidth_gb": 12.5,
        "requests": 45000,
        "success_rate": 98.5
      },
      {
        "timestamp": "2024-06-13T13:00:00Z",
        "connections": 210,
        "bandwidth_gb": 18.2,
        "requests": 62000,
        "success_rate": 99.1
      }
    ],
    "summary": {
      "total_bandwidth_gb": 245.8,
      "total_requests": 1250000,
      "average_success_rate": 98.7,
      "peak_connections": 290
    }
  }
}

Get Real-time Metrics

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.proxyomega.com/v1/proxy/metrics/realtime

{
  "success": true,
  "data": {
    "active_connections": 87,
    "throughput_mbps": 156.4,
    "requests_per_second": 342,
    "average_latency_ms": 45,
    "error_rate": 0.02,
    "proxy_types": {
      "unlimited": {
        "connections": 45,
        "throughput_mbps": 82.3
      },
      "platinum": {
        "connections": 32,
        "throughput_mbps": 64.1
      },
      "mobile": {
        "connections": 10,
        "throughput_mbps": 10.0
      }
    }
  }
}

Get Bandwidth Usage

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.proxyomega.com/v1/proxy/bandwidth/2024/06

{
  "success": true,
  "data": {
    "month": "2024-06",
    "daily_usage": [
      {
        "date": "2024-06-01",
        "bandwidth_gb": 125.4,
        "cost": 0.00
      },
      {
        "date": "2024-06-02",
        "bandwidth_gb": 143.2,
        "cost": 0.00
      }
    ],
    "total_bandwidth_gb": 3845.6,
    "total_cost": 0.00,
    "billing_type": "unlimited"
  }
}

Export Usage Report

curl -X POST -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "start_date": "2024-06-01",
    "end_date": "2024-06-30",
    "format": "csv",
    "include_details": true
  }' \
  https://api.proxyomega.com/v1/proxy/usage/export

Troubleshooting Guide

Common issues and their solutions when using ProxyOmega services.

Connection Issues

Authentication Errors

Performance Issues

IP Rotation Issues

# Force new IP on each request (no session parameter)
curl -x http://username:[email protected]:10000 https://example.com

# Use specific session for sticky IP
curl -x http://username-session_12345:[email protected]:10000 https://example.com

# Set custom rotation interval (mobile proxies)
curl -x http://username-rotate_5m:[email protected]:30000 https://example.com

Error Codes Reference