Geotargeting and session control

Adding targeting parameters

Connecting to Nimble IP with user:password authentication allows you to control session targeting and behavior by modifying the user portion of the request.

Selecting your target geolocation

To request an IP from a specific country, add country-<country_code> to the user portion:

curl -x http://account-accountName-pipeline-pipelineName-country-countryCode:[email protected]:7000 https://targetpage.com

import requests

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

url = 'https://ipinfo.io'

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

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

const axios = require('axios');

const targetAddress = "http://ipinfo.io/json";
const getProxy = async () => {
  return {
    proxy: {
      host: "account-accountName-pipeline-pipelineName-country-countryCode:[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!")
})();

package main

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

func main() {
	proxyURL, err := url.Parse("http://account-accountName-pipeline-pipelineName-country-countryCode:[email protected]")
	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))
}

We use ISO 3166 alpha-2 Country Codes (use ALL to randomly select a country).

If you’d like to get even more specific, you can also add state-<state_code> to target a US state. The list of state codes can be found here.

If no peers are available in a supported country/state/city, Nimble IP will return a 525 response. For more information, see Nimble IP's Response Codes.

Using sticky IPs

A sticky IP allows you to make multiple requests through the same IP address. This is done by initiating a session, which associates your request with the sticky IP address.

To create a session, add session-<random_string> to the user portion.

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.

For example:

curl -x http://account-accountName-pipeline-pipelineName-session-randomString:[email protected]:7000 https://targetpage.com

import requests

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

url = 'https://ipinfo.io'

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

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

const axios = require('axios');

const targetAddress = "http://ipinfo.io/json";
const getProxy = async () => {
  return {
    proxy: {
      host: "account-accountName-pipeline-pipelineName-session-randomString:[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!")
})();

package main

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

func main() {
	proxyURL, err := url.Parse("http://account-accountName-pipeline-pipelineName-session-randomString:[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))
}

Geo-sessions: longer, more stable, more accurate sessions

Nimble Geo-sessions are a next-gen session solution that provides a variety of upgrades, including:

Extended lifespans: Geo-sessions can last for days or even weeks, as opposed to minutes and hours like traditional sticky sessions.
Consistent Proxies: Geo-sessions select for the most stable proxies in our pool, reducing rotation during the session substantially.
Persistent Geolocation: Any rotated IP during the session is selected from a limited geographic zone that surrounds the original session IP .

Geo-sessions are incredibly easy to use; simply pass the parameter geosession along with a random string of your choosing that will serve as the Geo-session ID.

Geosession IDs are limited to between 16 to 32 alphanumeric characters (16 characters minimum).

For example:

curl -x http://account-accountName-pipeline-pipelineName-geosession-randomGeoSessionString:[email protected]:7000 https://targetpage.com

import requests

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

url = 'https://ipinfo.io'

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

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

const axios = require('axios');

const targetAddress = "http://ipinfo.io/json";
const getProxy = async () => {
  return {
    proxy: {
      host: "account-accountName-pipeline-pipelineName-geosession-randomGeoSessionString:[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!")
})();

package main

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

func main() {
	proxyURL, err := url.Parse("http://account-accountName-pipeline-pipelineName-geosession-randomGeoSessionString:[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))
}

Be sure to use the same parameters across requests that share the same Geo-session. If the location targeting is changed, but the Geo-session ID remains the same, a new session will still be initiated.

Geo-sessions are currently only supported within the US. Support for additional countries is coming soon.

Learn more about how Geo-sessions work and how to use them.

Combining parameters

All of the parameters we’ve covered before can be used together in a single request. This is done by chaining them together, like in this example:

curl -x http://account-MyCompany-pipeline-residential-country-US-state-NY-session-sess1:[email protected]:7000 https://ipinfo.io

import requests

proxies = {
    'http': 'http://account-MyCompany-pipeline-residential-country-US-state-NY-session-sess1:[email protected]:7000',
    'https': 'https://account-MyCompany-pipeline-residential-country-US-state-NY-session-sess1:[email protected]:7000'
}

url = 'https://ipinfo.io'

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

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

const axios = require('axios');

const targetAddress = "http://ipinfo.io/json";
const getProxy = async () => {
  return {
    proxy: {
      host: "account-MyCompany-pipeline-residential-country-US-state-NY-session-sess1:[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!")
})();

package main

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

func main() {
	proxyURL, err := url.Parse("http://account-MyCompany-pipeline-residential-country-US-state-NY-session-sess1:[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))
}

PreviousNimble IP Autentication NextResponse codes