Our paging documentation gives a brief overview of paged responses as well as URL use case examples for Version 2 of the API. This is a more in-depth look at paging for developers using our Javascript, Python, Ruby, Java, and C# SDKs.

Paging Overview

Each language has an appropriate api_response._next_page method which is used to redefine the next_page string. The examples below show some different methods that the retrieval and reuse of the next page string can be performed in our supported languages.


In Python, Java, and C#  the next_page is a string which can be changed directly, so the argument can be is changed directly from the returned value.

Python Example


...
max_number_pages_returned= 1000 # Integer | most pages that can be retrieved
stockPriceList = []

while max_number_pages_returned > 0:

  try:
    api_response = security_api.get_security_stock_prices(identifier, start_date=start_date, end_date=end_date, frequency=frequency, page_size=page_size, next_page=next_page)
    next_page = api_response._next_page
    for i in range(len(api_response._stock_prices)):
        stockPriceList.append(api_response._stock_prices[i])

  except ApiException as e:
    print("Exception when calling SecurityApi->get_security_stock_prices: %s\r\n" % e)
    break

  if next_page == None:
    break
  max_number_pages_returned -= 1

for j in range(len(stockPriceList)):
    pprint(stockPriceList[j])

Java Example



...

    Integer maxNumberPagesReturned = 1000;// Integer | The most
    ArrayList<StockPriceSummary> stockPriceList = new ArrayList<>();

    while (maxNumberPagesReturned != 0) {
      try {
        ApiResponseSecurityStockPrices result = securityApi.getSecurityStockPrices(identifier, startDate, endDate, frequency, pageSize, nextPage);
        nextPage = result.getNextPage();
        for(int i = 0; i < result.getStockPrices().size(); i++){
          stockPriceList.add(result.getStockPrices().get(i));
        }
        if (nextPage == null) {
          break;
        }
      } catch (ApiException e) {
        System.err.println("Exception when calling SecurityApi#getSecurityStockPrices");
        e.printStackTrace();
        break;
      }
      maxNumberPagesReturned--;
    }

    for(int j = 0; j < stockPriceList.size(); j++){
      System.out.println(stockPriceList.get(j));
    }

  }
}

C# Example

...

      var maxNumberOfPagesReturned = 1000;
      ApiResponseSecurityStockPrices result = null;
      ArrayList responses = new ArrayList();

      while (maxNumberOfPagesReturned > 0)
      {
        try
        {
          result = securityApi.GetSecurityStockPrices(identifier, startDate, endDate, frequency, pageSize, nextPage);
          nextPage = result.NextPage;          
          for (int i = 0; i < result.StockPrices.Count; i++)
          {
            Console.WriteLine(result.StockPrices[i]);
            responses.Add(result.StockPrices[i]);
          }
        }

        catch (Exception e)
        {
          Console.WriteLine("Exception when calling SecurityApi.GetSecurityStockPrices: " + e.Message);
          break;
        }

        if (nextPage == null)
        {
          break;
        }
        maxNumberOfPagesReturned--;
      }
     
      for (int j = 0; j < responses.Count; j++)
      {
        Console.WriteLine(responses[j]);
      }
    }
  }
}

Ruby uses hashes to store the arguments of the api call, thus when the next page key is returned, the string must be remerged into the hash. 

Ruby Example


...
max_number_pages_returned = 1000
next_page_key = nil
stock_Price_List = Array.new
opts = {
  start_date: Date.parse("2018-01-01"), # Date | Return prices on or after the date
  end_date: Date.parse("2019-01-02"), # Date | Return prices on or before the date
  frequency: "daily", # String | Return stock prices in the given frequency
  page_size: 100, # Integer | The number of results to return
  next_page: nil # String | Gets the next page of data from a previous API call
}

while max_number_pages_returned > 0
  begin
    results = security_api.get_security_stock_prices(identifier, opts)
    next_page_key = results.next_page
    opts_update = {next_page: next_page_key}
    opts.merge!(opts_update)

    for result in results.stock_prices
      stock_Price_List.push(result)
    end

  rescue Intrinio::ApiError => e
    puts "Exception when calling SecurityApi->get_security_stock_prices: #{e}"
    break
  end

  if next_page_key == nil
    break
  end
  max_number_pages_returned -= 1
end

for stock_Price in stock_Price_List
  pp stock_Price
end

Our Javascript API returns data using the promise format meaning that the eventual response will be asynchronous. Wrapping the API call in an async function allows us to await the response and provides synchronous executions. Since Javascript redefines its arguments every time the asynchronous function is called, the returned next string value is passed back to the function on recall.

Javascript Example

var intrinioSDK = require('intrinio-sdk');

async function getData() {
  responses = [];
  stockPriceList = [];
  var nextPage = null;
  var moreData = true;
  var maxNumberOfPagesReturned = 1000;

  while(maxNumberOfPagesReturned > 0){
    dataPage = await callApi(nextPage);
    responses.push(dataPage);
    nextPage = dataPage.next_page;

    if (!nextPage || nextPage == '') {
      break
    };
    maxNumberOfPagesReturned--;
  };

  for (const stockPrices of responses) {
    for (const stockPrice of stockPrices.stock_prices) {
      stockPriceList.push(stockPrice)
    };
  };

  for (const pricePrint of stockPriceList){
    console.log(pricePrint);
  }

};

async function callApi(nextPage = null) {
  intrinioSDK.ApiClient.instance.authentications['ApiKeyAuth'].apiKey = "YOUR_API_KEY";
  var securityAPI = new intrinioSDK.SecurityApi();
  var identifier = "AAPL"; // String | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID)

  var opts = {
    'startDate': new Date("2018-01-01"), // Date | Return prices on or after the date
    'endDate': new Date("2019-01-01"), // Date | Return prices on or before the date
    'frequency': "daily", // String | Return stock prices in the given frequency
    'pageSize': 100, // Number | The number of results to return
    'nextPage': nextPage // String | Gets the next page of data from a previous API call
  };

  data = await securityAPI.getSecurityStockPrices(identifier, opts);
  return data;
};

getData();

In Summation

In summation API v2 changed the paging system to a more efficient string based system rather than the integer system normally associated with paging. While this change added an extra step to the process of returning multiple pages, the String based system improved performance and reliability. All that is required is that the next page string returned from an API be placed back into the API call arguments and the subsequent page will be returned.For more information about our SDKs check out our product docs, community forum, or chat with us.

Did this answer your question?