LinkedIn API Guide

LinkedIn API Pagination with Start and Count Parameters

January 30, 2025

When working with LinkedIn’s API, retrieving large datasets efficiently is crucial for applications such as automation tools, analytics platforms, or CRM integrations. Pagination is the solution—it allows developers to fetch data in smaller, manageable chunks, ensuring optimal performance and avoiding API rate limits.

In this guide, we’ll explore how LinkedIn API uses the start and count parameters to implement pagination, with practical examples, best practices, and common pitfalls to help you manage data retrieval seamlessly.

Section 1: Understanding Pagination in LinkedIn API

What is Pagination and Why is it Necessary?
Pagination divides large datasets into smaller sections, making it easier to manage data requests without overloading the API or the client application. By fetching only a subset of records at a time, developers can efficiently process data while staying within LinkedIn’s API request quotas.

Start and Count Parameters Explained
LinkedIn API uses two key parameters for pagination:

  1. start: Defines the starting point or offset for the data to retrieve.
    Example: start=0 begins at the first record, while start=10 skips the first 10 records.
  2. count: Specifies the number of records to fetch in a single request.
    Example: count=10 retrieves 10 records per request.

How They Work Together
When combined, start and count allow developers to fetch a specific range of records. For example, a request with start=0 and count=10 retrieves the first 10 records, while start=10 and count=10 retrieves the next 10 records.

Section 2: Implementing Pagination with Start and Count Parameters

  1. Identify the Data You Need: Determine the endpoint and dataset you want to retrieve (e.g., connections, messages).
  2. Set Initial Parameters: Start with start=0 and choose an appropriate count value (e.g., 10 or 20).
  3. Iterate Through Data: Increment the start value by the count value in each request until all data is retrieved.

Example Request:

GET https://api.linkedin.com/v2/connections?start=0&count=10

Authorization: Bearer YOUR_ACCESS_TOKEN

Example Response:

{

  "elements": [

    { "id": "1", "name": "John Doe" },

    { "id": "2", "name": "Jane Smith" }

  ],

  "paging": {

    "start": 0,

    "count": 10,

    "total": 25

  }

}

Python Code Example:

import requests

ACCESS_TOKEN = "YOUR_ACCESS_TOKEN"

BASE_URL = "https://api.linkedin.com/v2/connections"

start = 0

count = 10

while True:

    response = requests.get(

        f"{BASE_URL}?start={start}&count={count}",

        headers={"Authorization": f"Bearer {ACCESS_TOKEN}"}

    )

    data = response.json()

    # Process the data

    for connection in data.get("elements", []):

        print(connection)

    # Check if there are more records to fetch

    if start + count >= data["paging"]["total"]:

        break

    # Increment start for the next batch

    start += count

This code iterates through all available records, fetching them in batches of 10.

Section 3: Best Practices and Common Mistakes

Best Practices for Pagination

  1. Choose the Right Batch Size: Start with a count value of 10 or 20 and optimize your batch size to balance performance and API limits. Larger values may reduce the number of requests but risk exceeding response size limits.
  2. Monitor API Rate Limits: Use LinkedIn’s response headers to track your remaining quota and implement backoff strategies if limits are exceeded.
  3. Validate Each Response: Ensure your code handles incomplete or missing data gracefully by checking the elements and paging fields in every response.

Common Pitfalls to Avoid

  • Skipping Records: Incorrectly calculating the start value can result in missing or duplicate records. Always increment start by the count value.
  • Overloading the API: Avoid setting an excessively high count value, as large requests can slow down the API or exceed memory limits.
  • Ignoring Errors: Handle HTTP errors (e.g., 429 Too Many Requests) by implementing retry logic with exponential backoff.

Error Handling Example:

import time

try:

    response = requests.get(...)

    response.raise_for_status()

except requests.exceptions.HTTPError as e:

    if response.status_code == 429:  # Rate limit exceeded

        time.sleep(60)  # Wait before retrying

    else:

        raise e

Conclusion

Efficient pagination is a critical skill for developers working with LinkedIn’s API, enabling the retrieval of large datasets while optimizing performance and respecting rate limits. By mastering the use of start and count parameters and following best practices, you can build robust automation tools that leverage LinkedIn’s data effectively.

Subscribe to our newsletter for more LinkedIn API tutorials and expert advice on building smarter automation tools!