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 Python Node.js Go
Copy curl -x http://account-accountName-pipeline-pipelineName-country-countryCode:[email protected] :7000 https://targetpage.com
Copy 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)
Copy 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!" )
})();
Copy 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 Python Node.js Go
Copy curl -x http://account-accountName-pipeline-pipelineName-session-randomString:[email protected] :7000 https://targetpage.com
Copy 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)
Copy 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!" )
})();
Copy 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 Python Node.js Go
Copy curl -x http://account-accountName-pipeline-pipelineName-geosession-randomGeoSessionString:[email protected] :7000 https://targetpage.com
Copy 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)
Copy 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!" )
})();
Copy 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 Python Node.js Go
Copy curl -x http://account-MyCompany-pipeline-residential-country-US-state-NY-session-sess1:[email protected] :7000 https://ipinfo.io
Copy 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)
Copy 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!" )
})();
Copy 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))
}