Authentication methods

Authenticated IPs

Instead of sending username and password credentials with every request, trusted IPs can be authenticated by adding them to your account's allow list, and any request coming from those authenticated IPs does not need to include a username or password.

It's important to be cautious with which IPs you authenticate. If a shared IP (such as an AWS shared IP) is authenticated, it's possible your account will be used by other parties through the shared IP.

Requests from authenticated IPs don't include credentials, and instead use a custom port to target a particular pipeline. You can define each pipeline's port range (between 9000 and 10000) when creating or modifying it. If the example request below were sent from an authenticated IP, its target port (9400) would be used to identify the relevant pipeline.

cURL

curl -x http://ip.nimbleway.com:9400 https://ipinfo.io

Python

import requests

proxies = {
    'http': 'http://ip.nimbleway.com:9400',
    'https': 'https://ip.nimbleway.com:9400'
}

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: "ip.nimbleway.com",
      port: 9400
    }
  }
}

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://ip.nimbleway.com:9400")
	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))
}

Geotargeting and Session settings

Because requests from authenticated IPs do not include a username portion, geotargeting and session parameters are set on the pipeline level only.

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

To learn more about working with authenticated IPs and managing pipelines, see the Backconnect Gateway Authentication methods page.