Controlling IP rotation

If retaining sessions for long periods of time with high geographic accuracy is important for your use case, we recommend trying our new Geo-sessions.

Using sticky sessions with user:password authentication

By default, IPs are rotated for every request. To create a sticky session and retain an IP for continuous use, add a –session– value to the username portion with an arbitrary session ID:

Session IDs are limited to 32 alphanumeric characters (no minimum). Session IDs cannot include hyphens "-" as this will act as a separator and end the "username" portion of the connection string.

cURL

curl -x http://account-accountName-pipeline-pipelineName-session-randomSessionString:[email protected]:7000 https://ipinfo.io

Python

import requests

proxies = {
    'http': 'http://account-accountName-pipeline-pipelineName-session-randomSessionString:[email protected]:7000',
    'https': 'https://account-accountName-pipeline-pipelineName-session-randomSessionString:[email protected]:7000'
}

url = 'https://ipinfo.io'

response = requests.get(url, proxies=proxies)

print(response.status_code)
print(response.text)

Node.js

const axios = require('axios');

const targetAddress = "http://ipinfo.io/json";
const getProxy = async () => {
  return {
    proxy: {
      host: "account-accountName-pipeline-pipelineName-session-randomSessionString:[email protected]",
      port: 7000
    }
  }
}

const run = async () => {
  const res = await axios(targetAddress, getProxy());
  return res.data;
}


(async () => {
  var response = await run()
  console.log(response);
  console.log("DONE!")
})();

Go

package main

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

func main() {
	proxyURL, err := url.Parse("http://account-accountName-pipeline-pipelineName-session-randomSessionString:[email protected]:7000")
	if err != nil {
		fmt.Println(err)
		return
	}

	client := &http.Client{
		Transport: &http.Transport{
			Proxy: http.ProxyURL(proxyURL),
		},
	}

	url := "https://ipinfo.io"

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

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

	fmt.Println(resp.StatusCode)

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

	fmt.Println(string(body))
}

A session retains its assigned IP as long as it remains active. If activity stops, Nimble will keep the session alive for 10 additional minutes before rotating the IP.

Using sticky sessions with Authenticated IPs

When using an Authenticated IP, your sticky/rotating session settings are defined only in the target pipeline's configuration. When defining/modifying a pipeline, you can choose if your IP should be rotated for every request, or in fixed session intervals such as 1, 3, 5, 10, or 30 minutes.

You can create/modify your pipelines in one of two ways:

• Using the Nimble IP page in the Nimble User Dashboard

• Using the /account/pipelines endpoint of the Admin API.

Handling IP Replacement

Inevitably, IPs will occasionally become unavailable during a session. Nimble provides you with three options that instruct our system how to handle an IP becoming unavailable during a session:

1. Replace IP when it's no longer available: Nimble will replace a lost IP with another IP that meets your original request settings.

2. Select another IP within the same ASN: Nimble will replace a lost IP with another IP from the same ASN as the previous one, improving the likelihood of smooth session resumption.

3. Do not replace - Fail request: Nimble will not replace the IP, and will fail the request with a message that the session's IP has been lost.

If retaining sessions for long periods of time with high geographic accuracy is important for your use case, we recommend trying our new Geo-sessions.

IP Replacement behavior is set in your pipeline settings. This can be adjusted via the Nimble Dashboard under the settings of each pipeline, or Nimble Admin API's /v1/account/pipelines/{pipelineName} "Update a Pipeline" endpoint.