High-Speed Datacenter Proxies

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

// Your KineticProxies API credentials
const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://api.kineticproxies.com/v1';

// Authentication header
const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

// Function to get available proxies
async function getProxies() {
  try {
    const response = await axios.get(`${BASE_URL}/proxies`, { headers });
    return response.data;
  } catch (error) {
    console.error(`Error: ${error.response?.status || error.message}`);
    return null;
  }
}

// Function to rotate IP for a specific proxy
async function rotateIp(proxyId) {
  try {
    const response = await axios.post(
      `${BASE_URL}/proxies/${proxyId}/rotate`,
      {},
      { headers }
    );
    return response.data;
  } catch (error) {
    console.error(`Error: ${error.response?.status || error.message}`);
    return null;
  }
}

// Function to use a proxy in your requests
async function makeRequestWithProxy(proxyId, targetUrl) {
  try {
    // Get proxy details first
    const proxyDetailsResponse = await axios.get(
      `${BASE_URL}/proxies/${proxyId}`, 
      { headers }
    );
    const proxyDetails = proxyDetailsResponse.data;
    
    const proxyUrl = `http://${proxyDetails.username}:${proxyDetails.password}@${proxyDetails.host}:${proxyDetails.port}`;
    
    // Create proxy agent
    const httpsAgent = new HttpsProxyAgent(proxyUrl);
    
    // Make the actual request through the proxy
    const response = await axios.get(targetUrl, {
      httpsAgent,
      timeout: 30000
    });
    
    return response.data;
  } catch (error) {
    console.error(`Request error: ${error.message}`);
    return null;
  }
}

// Example usage
async function main() {
  // Get all available proxies
  const proxies = await getProxies();
  
  if (proxies && proxies.length > 0) {
    // Use the first proxy
    const proxyId = proxies[0].id;
    
    // Rotate IP if needed
    await rotateIp(proxyId);
    
    // Make a request with the proxy
    const response = await makeRequestWithProxy(proxyId, 'https://api.ipify.org?format=json');
    if (response) {
      console.log(`Current IP: ${response.ip}`);
    }
  }
}

main().catch(console.error);

                                            

<?php

// Your KineticProxies API credentials
$apiKey = 'your_api_key_here';
$baseUrl = 'https://api.kineticproxies.com/v1';

// Headers for API requests
$headers = [
    'Authorization: Bearer ' . $apiKey,
    'Content-Type: application/json',
    'Accept: application/json'
];

/**
 * Get available proxies
 * @return array|null
 */
function getProxies() {
    global $baseUrl, $headers;
    
    $ch = curl_init($baseUrl . '/proxies');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    
    $response = curl_exec($ch);
    $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($statusCode === 200) {
        return json_decode($response, true);
    } else {
        echo "Error: " . $statusCode . "\n";
        return null;
    }
}

/**
 * Rotate IP for a specific proxy
 * @param string $proxyId
 * @return array|null
 */
function rotateIp($proxyId) {
    global $baseUrl, $headers;
    
    $ch = curl_init($baseUrl . '/proxies/' . $proxyId . '/rotate');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    
    $response = curl_exec($ch);
    $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($statusCode === 200) {
        return json_decode($response, true);
    } else {
        echo "Error: " . $statusCode . "\n";
        return null;
    }
}

/**
 * Make a request with a proxy
 * @param string $proxyId
 * @param string $targetUrl
 * @return array|null
 */
function makeRequestWithProxy($proxyId, $targetUrl) {
    global $baseUrl, $headers;
    
    // Get proxy details
    $ch = curl_init($baseUrl . '/proxies/' . $proxyId);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    
    $response = curl_exec($ch);
    $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($statusCode !== 200) {
        echo "Error getting proxy details: " . $statusCode . "\n";
        return null;
    }
    
    $proxyDetails = json_decode($response, true);
    $proxyUrl = $proxyDetails['host'] . ':' . $proxyDetails['port'];
    
    // Make request through proxy
    $ch = curl_init($targetUrl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_PROXY, $proxyUrl);
    curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyDetails['username'] . ':' . $proxyDetails['password']);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    
    $response = curl_exec($ch);
    $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    
    if (curl_errno($ch)) {
        echo "Request error: " . curl_error($ch) . "\n";
        curl_close($ch);
        return null;
    }
    
    curl_close($ch);
    
    if ($statusCode === 200) {
        return json_decode($response, true);
    } else {
        echo "Error in proxy request: " . $statusCode . "\n";
        return null;
    }
}

// Example usage
$proxies = getProxies();
if ($proxies && count($proxies) > 0) {
    // Use the first proxy
    $proxyId = $proxies[0]['id'];
    
    // Rotate IP if needed
    rotateIp($proxyId);
    
    // Make a request with the proxy
    $response = makeRequestWithProxy($proxyId, 'https://api.ipify.org?format=json');
    if ($response) {
        echo "Current IP: " . $response['ip'] . "\n";
    }
}

                                            

#!/bin/bash

# Your KineticProxies API credentials
API_KEY="your_api_key_here"
BASE_URL="https://api.kineticproxies.com/v1"

# Get available proxies
echo "Getting available proxies..."
PROXIES_RESPONSE=$(curl -s -X GET "${BASE_URL}/proxies" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json")

# Extract first proxy ID (using jq - install with: apt-get install jq)
PROXY_ID=$(echo "${PROXIES_RESPONSE}" | jq -r '.[0].id')

if [ -z "${PROXY_ID}" ] || [ "${PROXY_ID}" == "null" ]; then
  echo "Error: No proxies available or invalid response"
  exit 1
fi

echo "Using proxy with ID: ${PROXY_ID}"

# Rotate IP for this proxy
echo "Rotating IP..."
ROTATE_RESPONSE=$(curl -s -X POST "${BASE_URL}/proxies/${PROXY_ID}/rotate" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json")

# Get proxy details
echo "Getting proxy details..."
PROXY_DETAILS=$(curl -s -X GET "${BASE_URL}/proxies/${PROXY_ID}" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json")

# Extract proxy connection details
HOST=$(echo "${PROXY_DETAILS}" | jq -r '.host')
PORT=$(echo "${PROXY_DETAILS}" | jq -r '.port')
USERNAME=$(echo "${PROXY_DETAILS}" | jq -r '.username')
PASSWORD=$(echo "${PROXY_DETAILS}" | jq -r '.password')

echo "Proxy connection details:"
echo "Host: ${HOST}"
echo "Port: ${PORT}"
echo "Username: ${USERNAME}"
echo "Password: ${PASSWORD}"

# Use the proxy to make a request
echo "Making request through proxy..."
PROXY_REQUEST=$(curl -s --proxy "http://${USERNAME}:${PASSWORD}@${HOST}:${PORT}" \
  "https://api.ipify.org?format=json")

echo "Response: ${PROXY_REQUEST}"
CURRENT_IP=$(echo "${PROXY_REQUEST}" | jq -r '.ip')
echo "Current IP: ${CURRENT_IP}"

# Get proxy stats (bandwidth usage, etc.)
echo "Getting proxy statistics..."
PROXY_STATS=$(curl -s -X GET "${BASE_URL}/proxies/${PROXY_ID}/stats" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json")

echo "Proxy stats: ${PROXY_STATS}"

                                            

package main

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

const (
    apiKey  = "your_api_key_here"
    baseURL = "https://api.kineticproxies.com/v1"
)

// ProxyInfo represents the structure of proxy data
type ProxyInfo struct {
    ID       string `json:"id"`
    Host     string `json:"host"`
    Port     int    `json:"port"`
    Username string `json:"username"`
    Password string `json:"password"`
    Country  string `json:"country"`
    City     string `json:"city"`
    Carrier  string `json:"carrier"`
}

// IPResponse represents the response from ipify
type IPResponse struct {
    IP string `json:"ip"`
}

// getProxies retrieves available proxies from the API
func getProxies() ([]ProxyInfo, error) {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    req, err := http.NewRequest("GET", baseURL+"/proxies", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API request failed with status code: %d", resp.StatusCode)
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var proxies []ProxyInfo
    if err := json.Unmarshal(body, &proxies); err != nil {
        return nil, err
    }

    return proxies, nil
}

// rotateIP requests a new IP for the specified proxy
func rotateIP(proxyID string) error {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    req, err := http.NewRequest("POST", baseURL+"/proxies/"+proxyID+"/rotate", nil)
    if err != nil {
        return err
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("IP rotation failed with status code: %d", resp.StatusCode)
    }

    return nil
}

// getProxyDetails gets detailed information about a specific proxy
func getProxyDetails(proxyID string) (*ProxyInfo, error) {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    req, err := http.NewRequest("GET", baseURL+"/proxies/"+proxyID, nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("failed to get proxy details with status code: %d", resp.StatusCode)
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var proxyInfo ProxyInfo
    if err := json.Unmarshal(body, &proxyInfo); err != nil {
        return nil, err
    }

    return &proxyInfo, nil
}

// makeRequestWithProxy makes an HTTP request through the specified proxy
func makeRequestWithProxy(proxyInfo *ProxyInfo, targetURL string) (*IPResponse, error) {
    // Create proxy URL
    proxyURLStr := fmt.Sprintf("http://%s:%s@%s:%d", 
        proxyInfo.Username, 
        proxyInfo.Password, 
        proxyInfo.Host, 
        proxyInfo.Port,
    )
    
    proxyURL, err := url.Parse(proxyURLStr)
    if err != nil {
        return nil, err
    }

    // Create HTTP client with proxy
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
        Timeout: 30 * time.Second,
    }

    // Make the request
    resp, err := client.Get(targetURL)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("proxy request failed with status code: %d", resp.StatusCode)
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var ipResponse IPResponse
    if err := json.Unmarshal(body, &ipResponse); err != nil {
        return nil, err
    }

    return &ipResponse, nil
}

func main() {
    // Get available proxies
    proxies, err := getProxies()
    if err != nil {
        fmt.Printf("Error getting proxies: %v\n", err)
        return
    }

    if len(proxies) == 0 {
        fmt.Println("No proxies available")
        return
    }

    // Use the first proxy
    proxyID := proxies[0].ID
    fmt.Printf("Using proxy with ID: %s\n", proxyID)

    // Rotate the IP (optional)
    if err := rotateIP(proxyID); err != nil {
        fmt.Printf("Error rotating IP: %v\n", err)
    } else {
        fmt.Println("IP rotated successfully")
    }

    // Get detailed proxy information
    proxyInfo, err := getProxyDetails(proxyID)
    if err != nil {
        fmt.Printf("Error getting proxy details: %v\n", err)
        return
    }

    fmt.Printf("Proxy details: %+v\n", proxyInfo)

    // Make a request through the proxy
    ipResponse, err := makeRequestWithProxy(proxyInfo, "https://api.ipify.org?format=json")
    if err != nil {
        fmt.Printf("Error making request through proxy: %v\n", err)
        return
    }

    fmt.Printf("Current IP: %s\n", ipResponse.IP)
}