Pagination

List endpoints return results in pages. Understanding the pagination format lets you reliably fetch large datasets without missing or duplicating records.

Overview

Logimeter uses page-number-based pagination on all list endpoints that can return more records than a single response can contain. You request a specific page number and a page size; the API returns that slice of results along with metadata that tells you how to fetch the next or previous page.

Not every endpoint is paginated. Some endpoints — for example /v1/tn_prefixes/ and /v2/available_source/ — return a flat JSON array because their total result set is always small. You can tell immediately from the response shape: a paginated response is a JSON object with count, next, previous, and results keys; a non-paginated response is a plain JSON array ([...]).

Response format

All paginated list responses share the following envelope:

{
  "count": 150,
  "next": "https://next.logimeter.com/v2/contact/?page=3",
  "previous": "https://next.logimeter.com/v2/contact/?page=1",
  "results": [
    { ... },
    { ... }
  ]
}

Query parameters

Control pagination by appending query parameters to the request URL. Both parameters are optional — the API uses sensible defaults if they are omitted.

Examples

Fetching a specific page

Append ?page=2 (and optionally &page_size=50) to any list endpoint URL:

# Fetch page 2 with the default page size
curl "https://next.logimeter.com/v2/contact/?page=2" \
  -H "Authorization: Token YOUR_TOKEN"

# Fetch page 3 with 50 results per page
curl "https://next.logimeter.com/v2/contact/?page=3&page_size=50" \
  -H "Authorization: Token YOUR_TOKEN"

import requests

session = requests.Session()
session.headers['Authorization'] = 'Token YOUR_TOKEN'

# Fetch page 2 with 50 results per page
resp = session.get(
    'https://next.logimeter.com/v2/contact/',
    params={'page': 2, 'page_size': 50}
)
data = resp.json()

print(f"Page 2 of {-(-data['count'] // 50)} pages")
print(f"Results on this page: {len(data['results'])}")
print(f"Next page URL: {data['next']}")

const TOKEN = 'YOUR_TOKEN';

const resp = await fetch(
  'https://next.logimeter.com/v2/contact/?page=2&page_size=50',
  { headers: { 'Authorization': `Token ${TOKEN}` } }
);
const data = await resp.json();

console.log('Total results:', data.count);
console.log('Results on this page:', data.results.length);
console.log('Next URL:', data.next);

Iterating through all pages

When you need all records — for example during an initial data sync — follow the next URL until it is null. The example below collects every contact into a single list:

import requests

session = requests.Session()
session.headers['Authorization'] = 'Token YOUR_TOKEN'

def fetch_all(url):
    """Iterate all pages of a paginated list endpoint and return combined results."""
    results = []
    while url:
        resp = session.get(url)
        resp.raise_for_status()
        data = resp.json()
        results.extend(data['results'])
        url = data['next']  # None on the last page — loop ends
    return results

all_contacts = fetch_all('https://next.logimeter.com/v2/contact/?page_size=100')
print(f'Total contacts fetched: {len(all_contacts)}')

const TOKEN = 'YOUR_TOKEN';

async function fetchAll(startUrl) {
  const results = [];
  let url = startUrl;

  while (url) {
    const resp = await fetch(url, {
      headers: { 'Authorization': `Token ${TOKEN}` }
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);

    const data = await resp.json();
    results.push(...data.results);
    url = data.next; // null on the last page
  }

  return results;
}

const contacts = await fetchAll(
  'https://next.logimeter.com/v2/contact/?page_size=100'
);
console.log('Total contacts:', contacts.length);

Paginated vs. flat endpoints

Not all list endpoints use the paginated envelope. Some always return a flat array because their data sets are bounded in size. When integrating with an endpoint for the first time, check the response shape before writing pagination logic:

Tips

• Use page_size=100 for bulk reads. Requesting the maximum page size reduces the total number of HTTP round-trips needed to fetch all records.
• Do not construct page URLs manually. Always follow the next URL returned by the API. It includes any filter or ordering parameters that were on the original request, keeping your iteration consistent.
• Count the total before iterating. You can read count from the first response to give your users a progress indicator or to decide whether iterating all pages is worthwhile.
• Handle the last page. The final page's results array will be shorter than page_size when count is not a perfect multiple of page_size. Your code must not assume a full page.
• Avoid parallel page requests. Fetching multiple pages simultaneously can push you toward rate limits. Sequential page reads with the next link are the safest approach for bulk syncs.