Skip to main content

​
Why Do You Need an SSL Certificate?

To maintain a fully encrypted, end-to-end secure connection between your host and the target website while using Oculus Residential Proxies, an SSL certificate is required. You can either:
  • Install the SSL certificate manually (recommended for long-term use).
  • Ignore SSL errors in your code (temporary solution).

​
Download the SSL Certificate

To download the SSL certificate: 👉 Right-click on this link and select Save As to save it to your computer.

​
Using the SSL Certificate in Your Code

If you’re writing scraping code, you can load the SSL certificate in your code without installing it. For example, with CURL: 
curl --proxy "login:password@proxy.oculus-proxy.com:31113" --cacert "path/to/ssl_oculus_certificate.cer" "http://httpbin.org/ip"
For more sample code, refer to the Oculus Proxies Dashboard.

​
Installing the SSL Certificate

Some third-party tools require installing the SSL certificate in your environment. Follow the steps below based on your operating system or browser.
1. Double-click ssl_oculus_certificate.cer to open the certificate details.2. Click Install Certificate.3. Follow the on-screen instructions to complete the installation.

​
How to Ignore SSL Errors (Alternative Method)

If you don’t want to install the SSL certificate, you can ignore SSL errors in your code.

​
Examples for Different Programming Languages

# Add -k to ignore SSL errors
curl --proxy "[LOGIN]:[PASSWORD]@[HOST]:[PORT]" -k "http://httpbin.org/ip"

const axios = require('axios');

async function testProxy(proxy) {
  try {
      const response = await axios.get("http://httpbin.org/ip", {
          proxy,
          timeout: 5000
      });
      if (response.status === 200) {
          console.log(`Proxy %O is working. Your IP: ${response.data.origin}`, proxy);
      } else {
          console.log(`Proxy %O returned status code ${response.status}`, proxy);
      }
  } catch (error) {
      console.log(`Error occurred while testing proxy %O: ${error.message}`, proxy);
  }
}

async function main() {
  const proxy = {
      host: '[HOST]',
      port: '[PORT]',
      auth: {username: '[LOGIN]', password: '[PASSWORD]'},
  };
  await testProxy(proxy);
}

main();

import requests

def test_proxy(proxy):
  try:
      response = requests.get("http://httpbin.org/ip", proxies={"http": proxy, "https": proxy}, timeout=5)
      if response.ok:
          print(f"Proxy {proxy} is working. Your IP: {response.json()['origin']}")
      else:
          print(f"Proxy {proxy} returned status code {response.status_code}")
  except Exception as e:
      print(f"Error occurred while testing proxy {proxy}: {e}")

def main():
  proxy = "http://[LOGIN]:[PASSWORD]@[HOST]:[PORT]"
  test_proxy(proxy)

if __name__ == "__main__":
  main()

<?php

function testProxy($proxy) {
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, "http://httpbin.org/ip");
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($ch, CURLOPT_TIMEOUT, 5);
  curl_setopt($ch, CURLOPT_PROXY, $proxy['host']);
  curl_setopt($ch, CURLOPT_PROXYPORT, $proxy['port']);
  curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxy['login'] . ':' . $proxy['password']);
  $response = curl_exec($ch);
  $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  if ($httpCode == 200) {
      $data = json_decode($response, true);
      echo "Proxy {$proxy['host']}:{$proxy['port']} is working. Your IP: {$data['origin']}\n";
  } else {
      echo "Proxy {$proxy['host']}:{$proxy['port']} returned status code $httpCode\n";
  }
  if (curl_errno($ch)) {
      echo 'Error occurred while testing proxy ' . "{$proxy['host']}:{$proxy['port']}: " . curl_error($ch) . "\n";
  }
  curl_close($ch);
}

function main() {
  $proxy = [
      'host' => '[HOST]',
      'port' => '[PORT]',
      'login' => '[LOGIN]',
      'password' => '[PASSWORD]',
  ];
  testProxy($proxy);
}

main();
?>

package main

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

type IPResponse struct {
  Origin string `json:"origin"`
}

func testProxy(proxy *url.URL) {
  client := &http.Client{
      Transport: &http.Transport{
          Proxy: http.ProxyURL(proxy),
      },
      Timeout: 5 * time.Second,
  }
  resp, err := client.Get("http://httpbin.org/ip")
  if err != nil {
      fmt.Printf("Error occurred while testing proxy %s: %s\n", proxy.String(), err)
      return
  }
  defer resp.Body.Close()
  if resp.StatusCode == 200 {
      body, err := ioutil.ReadAll(resp.Body)
      if err != nil {
          fmt.Printf("Error reading response from proxy %s: %s\n", proxy.String(), err)
          return
      }
      var ipResp IPResponse
      if err := json.Unmarshal(body, &ipResp); err != nil {
          fmt.Printf("Error parsing JSON from proxy %s: %s\n", proxy.String(), err)
          return
      }
      fmt.Printf("Proxy %s is working. Your IP: %s\n", proxy.String(), ipResp.Origin)
  } else {
      fmt.Printf("Proxy %s returned status code %d\n", proxy.String(), resp.StatusCode)
  }
}

func main() {
  proxyStr := "http://[LOGIN]:[PASSWORD]@[HOST]:[PORT]"
  proxyURL, err := url.Parse(proxyStr)
  if err != nil {
      fmt.Printf("Invalid proxy URL %s: %s\n", proxyStr, err)
  } else {
      testProxy(proxyURL)
  }
}

​
How Does SSL Analyzing Work?

Some features require the Proxy Manager to access HTTPS traffic. This is done by enabling SSL Analyzing in the proxy port configuration settings. 1. How It Works:
  • Proxy Manager establishes an encrypted HTTPS connection to the target site.
  • The traffic is decrypted and analyzed (e.g., for logging requests or running rules).
  • The response is sent back to the client with a certificate signed by Oculus Proxies CA.
2. To Enable SSL Analyzing: Enabling SSL analyzing ensures that secure traffic is properly processed while maintaining encryption throughout the session.

​
You’re All Set!

Now that your SSL certificate is installed, you can securely access websites using Oculus Proxies without interruptions. Whether you’re scraping, automating, or managing multiple accounts, your connection remains encrypted, private, and reliable.