Forward Network API

@Rohit_809 Kumar I don’t think there is a single published API that would provide this data.  However, you can use NQE to essentially make “custom APIs”.

An NQE query can be accessed via a single API call /api/nqe.  This is a POST, so there are options you can put into the body of the request.  You would then write an NQE query that would list all the data that you want about a device.  You could either run it as a non-parameterized query, where you do NOT pass in a device name.  This would then give you this set of data for ALL devices covered in the NQE query. Or, you can use the parameterized NQE method to be able to pass in a single device name and get all this data back about that single device.

The NQE method does have a max limit of 10,000 lines in one response.  There is a “offset” and “limit” to “page” through the results.  The default limit is 1,000, but in the body of the post you can set the “limit” to 10,000.

If you are just returning the output for a single device then you are less likely to run into exceeding that 10,000 max limit.

Hello @Rohit_809 Kumar 

As ​​​@Tyson Henrie mentioned you can execute NQE using our `/api/nqe` endpoint by using the queryId which can be found in the NQE Library:
 

Passing it in the body of your HTTP POST

curl -X 'POST' \
  'https://fwd.app/api/nqe?networkId=<networkID>' \
  -H 'accept: application/json' \
  -H 'Authorization: Basic <auth> \
  -H 'Content-Type: application/json' \
  -d '{
  "queryId": "FQ_ac651cb2901b067fe7dbfb511613ab44776d8029"
}'

You can also do this by using a text query
 

curl -X 'POST' \
  'https://fwd.app/api/nqe?networkId=<networkId>' \
  -H 'accept: application/json' \
  -H 'Authorization: Basic <AUTH>' \
  -H 'Content-Type: application/json' \
  -d '{
  "query": "foreach d in network.devices select { Device: d.name }"
}'

Please consult our API documentation https://fwd.app/api-doc#nqe for more details​​​​​​

thanks @Tyson Henrie this is very helpful.

@Rohit_809 Kumar 

The API already supports pagination when the # of records > limit. You simply need to wrap the call to NQE so that you can make multiple fetches based on the limit window.

Below as an example in Python but you could write this in any general purpose language.
 

# Note this is just an example, no guarantees, please make sure you understand what this code is doing before running. 

import requests

def callNqe(query, appserver, snapshot, username, password, headers, debug=False):
    url = f"https://{appserver}/api/nqe?snapshotId={snapshot}"
    limit = 10000
    offset = 0
    items = []

    if debug:
        print("Calling nqe")

    while True:
        body = {"query": query, "queryOptions": {"limit": limit, "offset": offset}}
        if debug:
            print(f"{body}, {url}, {headers}, {username}")

        try:
            response = requests.post(
                url,
                json=body,
                auth=(username, password),
                headers=headers,
                verify=False,
            )
            response.raise_for_status()
            response_json = response.json()

            if debug:
                print(f"Offset: {offset}, Items: {len(response_json['items'])}, Total: {len(items)}")

            if not response_json["items"]:
                break

            items.extend(response_json["items"])
            offset += limit

        except requests.exceptions.HTTPError as err:
            response_status = response.status_code
            if response_status in [401, 403]:
                print("Please set FWD_USER and FWD_PASSWORD to authentication credentials")
            elif response_status == 409:
                print("Snapshot is being processed, try again in a few")
            raise SystemExit(err)

        except requests.exceptions.ConnectionError as err:
            print(f"Connection error occurred: {err}")
            break

    return items

@Rohit_809 Kumar As @Tyson Henrie  mentioned and what is in our documentation, the maximum limit is 10,000.

So we increment the offset by 10,000 every round until there are no more items returned. 
 

offset += limit