---
title: "CallListV3.make"
description: "Method for quickly retrieving all data from list methods of Bitrix24 REST API version 3."
canonical_url: "https://bitrix24.github.io/b24jssdk/docs/working-with-the-rest-api/call-list-rest-api-ver3"
last_updated: "2026-05-08"
---
# CallListV3.make

> Method for quickly retrieving all data from list methods of Bitrix24 REST API version 3.

> [!WARNING]
> We are still updating this page. Some data may be missing here — we will complete it shortly.

> [!NOTE]
> It's important to note that REST API version 3 allows you to retrieve up to 1000 elements in a single request using the pagination `parameter: { limit: 1000, page: 1 }`.

## Overview

When you need to retrieve all records from list methods of REST API version 3 with maximum efficiency and are ready to store the complete dataset in memory, use `CallListV3.make()`.

This method automatically handles pagination and returns all data in a single array.

> [!NOTE]
> For importing, exporting, processing all elements and generating reports, we recommend using [`FetchList`](https://bitrix24.github.io/b24jssdk/raw/docs/working-with-the-rest-api/fetch-list-rest-api-ver3.md) - it returns an asynchronous generator for step-by-step processing of large lists.

```ts
// Basic usage
const response = await $b24.actions.v3.callList.make({
  method: 'main.eventlog.list',
  params: {
    filter: [
      ['userId', '=', 1]
    ],
    select: ['id', 'userId']
  },
  idKey: 'id',
  customKeyForResult: 'items',
  requestId: 'unique-request-id',
  limit: 600
})
```

### When to Use CallListV3.make()

1. **Small to medium data volumes**: When the total number of records does not exceed several thousand.
2. **Simple processing**: When you need simple access to all data at once.

## Method Signature

```ts-type
make<T = unknown>(
  options: ActionCallListV3
): Promise<Result<T[]>>
```

### Parameters

The `options` object contains the following properties:

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| **`method`** | `string` | Yes | REST API method name that returns a data list (e.g., `crm.contact.list` , `tasks.task.list` ). |
| **`params`** | `OmitTypeCallParams,'pagination'|'order'>` | No | Request parameters, excluding the `pagination` and `order` parameters. The `pagination` parameter is reserved because the method retrieves all data in a single call. The `order` parameter is reserved because cursor-based pagination requires sorting strictly by `idKey` ascending — see Limitations . Use `filter` and `select` to control the selection. |
| **`idKey`** | `string` | No | Name of the field containing the unique element identifier. Default: `'id'` . Can also be another field depending on the REST API data structure. |
| **`customKeyForResult`** | `string` | Yes | Custom key indicating that the REST API response will be selected by this field. For example: `items` for a list of CRM elements. |
| **`requestId`** | `string` | No | Unique request identifier for tracking. Used for request deduplication and debugging. |
| **`limit`** | `number` | No | How many records to retrieve at a time. Default is `50` . Maximum is `1000` . |

### Return Value

`Promise<Result<T[]>>` — a promise that resolves to a [`Result<T[]>`](https://github.com/bitrix24/b24jssdk/blob/main/packages/jssdk/src/core/result.ts) object containing an array of all retrieved elements.

This object provides:

- `.getData(): T[]` — returns an array of all retrieved elements.
- `.isSuccess: boolean` — flag indicating successful execution of all requests.
- `.getErrorMessages(): string[]` — array of error messages.

## Key Concepts

### Performance Optimization

The method implements the [Bitrix24 recommended algorithm](https://apidocs.bitrix24.com/settings/performance/huge-data.html) for efficient work with large data volumes:

1. **Filtering by increasing id**: Each subsequent query uses a `>id` filter with the id of the last retrieved element.
2. **Automatic data end detection**: Requests stop when an empty array is received or the number of elements is less than the page size (`options.limit`).

### REST API v3 Response Structure

> [!NOTE]
> The `customKeyForResult` parameter is retained for backward compatibility. In the future, after analyzing real usage, a decision will be made regarding its necessity.

In REST API version 3, various methods return data in the same structures:

- **Grouped array**: `{ result: { items: [...] } }`

The `customKeyForResult` parameter allows you to specify the key where the data is located in the response.

### Limitations

- **Page size**: Bitrix24 REST API version 3 limitation — maximum `1000` records per request.
- **Sorting is fixed**: The method always sorts by `idKey` ascending, because cursor pagination relies on `[idKey, '>', nextId]` filters to walk the dataset. A user-supplied `order` value would break that invariant, so the type signature excludes `order` and any value passed at runtime is stripped with a `warning` log entry. To narrow the result set, use `filter` instead.
- **Only for list methods**: Intended only for methods that return data arrays.

## Error Handling

Always check the result using `isSuccess` and handle errors:

```ts
const response = await $b24.actions.v3.callList.make({
  method: 'some.method',
  params: { /* some_params */ },
  idKey: 'id',
  customKeyForResult: 'items',
  requestId: 'unique-request-id',
  limit: 600
})

if (!response.isSuccess) {
  // Handling error
  console.error(new Error(`Error: ${response.getErrorMessages().join('; ')}`))
  return
}

// Working with a successful result
const data = response.getData()
```

## Examples

### Getting all Event Log Items with filtering

```ts [AllMainEventLogItems.ts]
import { B24Hook, LoggerFactory, Text, SdkError, AjaxError } from '@bitrix24/b24jssdk'

type MainEventLogItem = {
  id: number
  userId: number
}

const devMode = typeof import.meta !== 'undefined' && (import.meta.dev || import.meta.env?.DEV)
const $logger = LoggerFactory.createForBrowser('Example:AllMainEventLogItems', devMode)
const $b24 = B24Hook.fromWebhookUrl('https://your_domain.bitrix24.com/rest/1/webhook_code/')

async function getMainEventLogItemList(requestId: string): Promise<MainEventLogItem[]> {
  const sixMonthAgo = new Date()
  sixMonthAgo.setMonth((new Date()).getMonth() - 6)
  sixMonthAgo.setHours(0, 0, 0)

  const response = await $b24.actions.v3.callList.make<MainEventLogItem>({
    method: 'main.eventlog.list',
    params: {
      filter: [
        ['timestampX', '>=', Text.toB24Format(sixMonthAgo)] // created at least 6 months ago
      ],
      select: ['id', 'userId']
    },
    idKey: 'id',
    customKeyForResult: 'items',
    requestId,
    limit: 60
  })

  if (!response.isSuccess) {
    throw new SdkError({
      code: 'MY_APP_GET_PROBLEM'
      description: `Problem ${response.getErrorMessages().join('; ')}`,
      status: 404
    })
  }

  return response.getData()
}

// Usage
const requestId = 'some-main-event-log-item-list'
try {
  const list = await getMainEventLogItemList(requestId)
  $logger.info(`List [${list?.length}]`, { requestId, list })
} catch (error) {
  if (error instanceof AjaxError) {
    $logger.critical(error.message, { requestId, code: error.code })
  } else {
    $logger.alert('Problem', { requestId, error })
  }
}
```

## Alternatives and Recommendations

- **For working with lists:** Instead of manually managing pagination use:

 - [`FetchList`](https://bitrix24.github.io/b24jssdk/raw/docs/working-with-the-rest-api/fetch-list-rest-api-ver3.md) — returns an async generator for step-by-step processing of large lists.
- **For batch operations:** Use [`Batch`](https://bitrix24.github.io/b24jssdk/raw/docs/working-with-the-rest-api/batch-rest-api-ver3.md) to execute up to 50 commands in a single request.
- **On the client-side (browser):** Use the built-in [`B24Frame`](https://bitrix24.github.io/b24jssdk/raw/docs/getting-started/installation/vue.md#init) object.

## Sitemap

See the full [sitemap](/b24jssdk/sitemap.md) for all pages.