> ## Documentation Index
> Fetch the complete documentation index at: https://docs.oculusproxies.com/llms.txt
> Use this file to discover all available pages before exploring further.

# SSL Certificate

> Learn how to install and use an SSL certificate with Oculus Residential Proxies to ensure a secure and encrypted connection between your host and target website.

## 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](https://oculusproxies.com/ssl_oculus_certificate.cer) 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***:

```bash theme={null}
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.

<Tabs>
  <Tab title="Windows">
    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.
  </Tab>

  <Tab title="Chrome">
    1\. Type `chrome://settings/privacy` in the address bar.

    2\. Click **Security**.

    3\. Scroll down and click **Manage certificates**.

    4\. Go to the **Trusted Certification Authorities** tab and click **Import**.

    5\. Click **Next** and select the downloaded certificate.

    6\. Select **Place all certificates in the following store** → Choose **Trusted Root Certification Authorities**.

    7\. Click **Finish**.
  </Tab>

  <Tab title="Firefox">
    1\. Type `about:preferences#privacy` in the address bar.

    2\. Scroll to the **Certificates** section.

    3\. Click **View Certificates** → Open **Certificate Manager**.

    4\. Select the **Authorities** tab and click **Import**.

    5\. Choose the downloaded certificate and click **Open**.

    6\. Check **Trust this CA to identify websites** and click **OK**.
  </Tab>

  <Tab title="Linux">
    1\. Move the downloaded certificate to `/usr/local/share/ca-certificates/`:

    ```bash theme={null}
    sudo mv ssl_oculus_certificate.cer /usr/local/share/ca-certificates/
    ```

    2\. Run:

    ```bash theme={null}
    sudo update-ca-certificates
    ```

    3\. The output should confirm that one certificate was added.

    4\. Visit an SSL-protected website to verify the installation.
  </Tab>

  <Tab title="macOS">
    1\. Open **Keychain Access**.

    2\. Drag and drop `ssl_oculus_certificate.cer` into **System**.

    3\. Double-click the certificate → Expand **Trust**.

    4\. Set **When using this certificate** to **Always Trust**.

    5\. Restart your browser and verify by visiting an SSL-protected website.
  </Tab>

  <Tab title="iOS">
    1\. Download the certificate via Safari.

    2\. Go to **Settings → General → About → Certificate Trust Settings**.

    3\. Enable the certificate and restart your device.
  </Tab>

  <Tab title="Android">
    1\. Download the certificate and save it.

    2\. Go to **Settings → Security → Encryption & Credentials**.

    3\. Select **Install a certificate** → Choose **VPN and apps**.

    4\. Locate and install the certificate.

    5\. Restart your device and visit an SSL-protected website to verify.
  </Tab>
</Tabs>

***

## 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**

<CodeGroup>
  ```bash Curl theme={null}
  # Add -k to ignore SSL errors
  curl --proxy "[LOGIN]:[PASSWORD]@[HOST]:[PORT]" -k "http://httpbin.org/ip"
  ```

  ```bash Node.js theme={null}
  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();
  ```

  ```python Python theme={null}
  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 PHP theme={null}
  <?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();
  ?>
  ```

  ```go Go theme={null}
  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)
    }
  }
  ```
</CodeGroup>

***

## 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:**

* **Allow Proxy Manager to terminate SSL traffic**.

* [Trust the Oculus Proxies CA certificate](https://oculusproxies.com/ssl_oculus_certificate.cer).

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**.