Get the Manifest of the landing.block.getmanifest Method

Choose a tool for developing with an AI agent:

use Alaio Vibecode to build an app for Bitrix24 from a task description without knowing any programming language. The agent writes the code and deploys the app to a server, with no manual hosting setup
use the MCP server to develop a REST API integration in your own project. The agent refers to the official REST documentation

Scope: landing

Who can execute the method: a user with "view" access permission for pages

The landing.block.getmanifest method returns a prepared manifest of the block placed on the page.

It does not return the original file but rather the prepared data for a specific block. For example, localized titles, fields such as code, preview, assets, timestamp, and callbacks.

Method Parameters

Required parameters are marked with *

Name `type`	Description
scope `string`	Internal scope of the landing. It is not related to the REST scope `landing` in the method name. The value of `scope` must correspond to the type of site (detailed description)
lid* `integer`	Page identifier. The page identifier can be obtained using the landing.landing.getlist method
block* `integer`	Block identifier. The block must belong to the page `lid` in the selected version of the page. The block identifier can be obtained using the landing.block.getlist method
params `object`	Additional parameters for reading the manifest (detailed description)

Parameter params

Name
type

Description

edit_mode
boolean | integer

If the value is cast to true, the method reads the draft of the page instead of the published version. Default is false.

Without this parameter, the method searches for the block only in the published version of the page.

Code Examples

How to Use Examples in Documentation

cURL (Webhook)

cURL (OAuth)

JS (TS)

JS (UMD)

Python

PHP

BX24.js

PHP CRest

curl -X POST \
          -H "Content-Type: application/json" \
          -d '{
            "lid": 4858,
            "block": 39556,
            "params": {
              "edit_mode": true
            }
          }' \
          "https://**put.your-domain-here**/rest/**user_id**/**webhook_code**/landing.block.getmanifest.json"

curl -X POST \
          -H "Content-Type: application/json" \
          -d '{
            "lid": 4858,
            "block": 39556,
            "params": {
              "edit_mode": true
            },
            "auth": "**put_access_token_here**"
          }' \
          "https://**put.your-domain-here**/rest/landing.block.getmanifest.json"

// This snippet is an ES module: top-level await requires type="module" or a bundler.
        // $b24 is an already-initialized SDK instance (see the SDK "Get started" guide).
        import { Text } from '@bitrix24/b24jssdk'
        import type { B24Frame } from '@bitrix24/b24jssdk'
        
        declare const $b24: B24Frame
        
        // Shape of the payload returned in result (match the "response handling" section of the page)
        type GetManifestResult = {
          block: {
            name: string
            section: string[]
            dynamic: boolean
            subtype?: string | string[]
          }
          nodes: Record<string, unknown>
          style: Record<string, unknown>
          assets: {
            css: string[]
            js: string[]
            ext: string[]
            class: string[]
            callbacks: unknown[]
          }
          timestamp: number
          callbacks: Record<string, unknown>
          attrs: Record<string, unknown>
          cards: unknown[]
          menu: unknown[]
          namespace: string
          code: string
          preview: string
        }
        
        try {
          const response = await $b24.actions.v2.call.make<GetManifestResult>({
            method: 'landing.block.getmanifest',
            params: {
              lid: 4858,
              block: 39556,
              params: {
                edit_mode: true,
              },
            },
            requestId: Text.getUuidRfc4122()
          })
        
          // The payload is available only on a successful response
          if (!response.isSuccess) {
            console.error(response.getErrorMessages().join('; '))
          } else {
            const result = response.getData()!.result
            console.info(result.block.name, result.code, result.preview)
          }
        } catch (error) {
          // Thrown on transport or SDK failures (AjaxError, SdkError, etc.)
          console.error(error)
        }

<!-- Load the SDK (UMD build); it is exposed as the global B24Js -->
        <script src="https://unpkg.com/@bitrix24/b24jssdk@1/dist/umd/index.min.js"></script>
        <script>
          async function getBlockManifest() {
            try {
              // Initialize the SDK inside a Bitrix24 frame
              const $b24 = await B24Js.initializeB24Frame()
        
              const response = await $b24.actions.v2.call.make({
                method: 'landing.block.getmanifest',
                params: {
                  lid: 4858,
                  block: 39556,
                  params: {
                    edit_mode: true,
                  },
                },
                requestId: B24Js.Text.getUuidRfc4122()
              })
        
              // The payload is available only on a successful response
              if (!response.isSuccess) {
                console.error(response.getErrorMessages().join('; '))
                return
              }
        
              const result = response.getData().result
              console.info(result.block.name, result.code, result.preview)
            } catch (error) {
              // Thrown on transport or SDK failures (AjaxError, SdkError, etc.)
              console.error(error)
            }
          }
        
          document.addEventListener('DOMContentLoaded', getBlockManifest)
        </script>

from b24pysdk.errors import BitrixAPIError, BitrixSDKException
        
        try:
            bitrix_response = client.landing.block.getmanifest(
                lid=4858,
                block=39556,
                params={
                    "edit_mode": True,
                },
            ).response
            result = bitrix_response.result
            print(result)
        except BitrixAPIError as error:
            print(
                "Bitrix API error",
                f"error: {error.error}",
                f"error_description: {error.error_description}",
                sep="\n",
            )
        except BitrixSDKException as error:
            print(f"Bitrix SDK error: {error.message}")
        except Exception as error:
            print(f"Unexpected error: {error}")

try {
            $response = $b24Service
                ->core
                ->call(
                    'landing.block.getmanifest',
                    [
                        'lid' => 4858,
                        'block' => 39556,
                        'params' => [
                            'edit_mode' => true,
                        ],
                    ]
                );
        
            $result = $response
                ->getResponseData()
                ->getResult();
        
            echo 'Success: ' . var_export($result, true);
        } catch (Throwable $e) {
            error_log($e->getMessage());
            echo 'Error getting block manifest: ' . $e->getMessage();
        }

BX24.callMethod(
            'landing.block.getmanifest',
            {
                lid: 4858,
                block: 39556,
                params: {
                    edit_mode: true
                }
            },
            function(result)
            {
                if (result.error())
                {
                    console.error(result.error());
                }
                else
                {
                    console.info(result.data());
                }
            }
        );

require_once('crest.php');
        
        $result = CRest::call(
            'landing.block.getmanifest',
            [
                'lid' => 4858,
                'block' => 39556,
                'params' => [
                    'edit_mode' => true,
                ],
            ]
        );
        
        if (isset($result['error']))
        {
            echo 'Error: ' . $result['error_description'];
        }
        else
        {
            echo '<pre>';
            print_r($result['result']);
            echo '</pre>';
        }

// client and ctx are already created — see the Go SDK section
        res, err := client.Core().Call(ctx, "landing.block.getmanifest", b24.Params{
        	"lid":   4858,
        	"block": 39556,
        	"params": b24.Params{
        		"edit_mode": true,
        	},
        })
        if err != nil {
        	return fmt.Errorf("landing.block.getmanifest: %w", err)
        }
        
        var item struct {
        	Timestamp int    `json:"timestamp"`
        	Namespace string `json:"namespace"`
        	Code      string `json:"code"`
        	Preview   string `json:"preview"`
        }
        if err := json.Unmarshal(res.Result, &item); err != nil {
        	return fmt.Errorf("parse response: %w", err)
        }
        fmt.Println(item.Timestamp, item.Namespace)

Response Handling

HTTP Status: 200

{
            "result": {
                "block": {
                    "name": "Form on a light background in the center",
                    "section": [
                        "forms"
                    ],
                    "dynamic": false,
                    "subtype": "form",
                    "attrsFormDescription": "<a href=\"/crm/webform/\" target=\"_blank\">Configure CRM forms</a>"
                },
                "nodes": {
                    "#wrapper": {
                        "type": "styleimg",
                        "code": "#wrapper"
                    }
                },
                "style": {
                    "block": {
                        "type": [
                            "block-default",
                            "block-border"
                        ]
                    },
                    "nodes": {
                        ".bitrix24forms": {
                            "type": "crm-form"
                        }
                    }
                },
                "assets": {
                    "css": [],
                    "js": [],
                    "ext": [
                        "landing_form"
                    ],
                    "class": [],
                    "callbacks": []
                },
                "timestamp": 1751467642,
                "callbacks": {
                    "afteradd": {}
                },
                "attrs": {
                    ".bitrix24forms": [
                        {
                            "name": "Embed form flag",
                            "attribute": "data-b24form-embed",
                            "type": "string",
                            "hidden": true
                        },
                        {
                            "name": "Form design",
                            "attribute": "data-b24form-design",
                            "type": "string",
                            "hidden": true
                        },
                        {
                            "name": "Form from connector flag",
                            "attribute": "data-b24form-connector",
                            "type": "string",
                            "hidden": true
                        },
                        {
                            "name": "CRM form",
                            "attribute": "data-b24form",
                            "items": [
                                {
                                    "name": "Feedback form",
                                    "value": "#crmFormInline3"
                                },
                                {
                                    "name": "Contact details with comment",
                                    "value": "#crmFormInline39"
                                }
                            ],
                            "type": "list"
                        },
                        {
                            "name": "Form design",
                            "attribute": "data-b24form-use-style",
                            "type": "list",
                            "items": [
                                {
                                    "name": "Use block design",
                                    "value": "Y"
                                },
                                {
                                    "name": "Use CRM form design",
                                    "value": "N"
                                }
                            ]
                        }
                    ]
                },
                "cards": [],
                "menu": [],
                "namespace": "bitrix",
                "code": "33.13.form_2_light_no_text",
                "preview": "/bitrix/blocks/bitrix/33.13.form_2_light_no_text/preview.jpg"
            },
            "time": {
                "start": 1774521323,
                "finish": 1774521323.212432,
                "duration": 0.2124319076538086,
                "processing": 0,
                "date_start": "2026-03-26T13:35:23+01:00",
                "date_finish": "2026-03-26T13:35:23+01:00",
                "operating_reset_at": 1774521923,
                "operating": 0
            }
        }

Returned Data

Name
type

Description

result
object

The prepared manifest of the block (detailed description). The general format of the manifest is described in the article Manifest File.

Empty sections of the manifest may return as empty arrays [], even if they usually contain an object with keys

time
time

Information about the execution time of the request

Object result

Name `type`	Description
block `object`	Main properties of the block from the manifest (detailed description)
cards `object`	Description of the block cards, if any. If there are no cards, it may return an empty array `[]`
nodes `object`	Description of the editable nodes of the block. For each node, the method additionally adds a `code` key with the node selector. For nodes with a separate handler in the editor, the method also adds a `handler` key with the name of that handler. If there are no nodes, it may return an empty array `[]`
attrs `object`	Description of customizable attributes of the block, if any. If there are no attributes, it may return an empty array `[]`
menu `object`	Description of the block menu, if any. If there is no menu, it may return an empty array `[]`
style `object`	Description of available style settings for the block. If the original manifest does not separate styles into `style.block` and `style.nodes`, the method will sort them into these sections itself
namespace `string`	Namespace of the block. For built-in blocks in Bitrix24, this is usually `bitrix`. For blocks from applications, the value is set by the application, so it may differ or be empty
code `string`	Block code
preview `string`	Relative path to the preview file `preview.jpg`. If the preview file is missing, an empty string will be returned. For blocks registered via REST API or applications, this field returns an empty string
assets `object`	Block resources (detailed description)
timestamp `integer`	Time of the base manifest update in Unix Timestamp format. For a local block, this is the time of the file `block.php` modification. For a block from an application, this is the time of the last update of the block in the application
callbacks `object`	Callback handlers from the block manifest. The names of the handlers are converted to lowercase by the method

The result may contain other keys from the original manifest. Their composition depends on the specific block.

Object block

Name `type`	Description
name `string`	Name of the block
section `string[]`	Sections to which the block belongs
dynamic `boolean`	Indicator of a dynamic block
subtype `string` \| `string[]`	Subtype of the block, if specified

In the block object, there may be other fields of the manifest. Their set depends on the specific block.

Object assets

Name `type`	Description
css `string[]`	List of CSS resources for the block. This includes paths from the manifest and any automatically found local `style.css`, if available. For design local blocks, `design_style.css` is automatically included instead of `style.css`
js `string[]`	List of JS resources for the block. This includes paths from the manifest and any automatically found local `script.js`, if available
ext `string[]`	List of client extensions for the block. For REST blocks, the method returns only extensions from the allowed list
class `string[]`	Service paths to PHP classes of the block on the server. For most regular calls, this array is empty or not needed for client code
callbacks `array`	List of callback functions from the `assets` section of the manifest, if declared. Unlike `result.callbacks`, this field pertains to the resources of the block, not to the handlers of the block itself

Error Handling

HTTP Status: 400

{
            "error": "BLOCK_NOT_FOUND",
            "error_description": "Block not found"
        }

Name `type`	Description
error `string`	String error code. It consists of digits, Latin letters, and underscores. It may arrive empty — in that case only `error_description` shows the reason
error_description `string`	Error message for the developer. Do not show it to the end user without processing

Possible Error Codes

Code	Description
`MISSING_PARAMS`	Required parameter `lid` or `block` is missing
`ACCESS_DENIED`	User does not have permission to view the page
`LANDING_NOT_EXIST`	Page with identifier `lid` not found, deleted, or unavailable to the current user
`BLOCK_NOT_FOUND`	Block with identifier `block` not found on the page in the selected version

Statuses and System Error Codes

HTTP Status: 4xx, 5xx

The errors described below are returned by the REST API itself, not by the logic of a specific method. They can arrive in response to any method.

Status	Code Error Message	Description
`500`	`INTERNAL_SERVER_ERROR` Internal server error	An internal server error has occurred. Retry the call, and if the error persists, contact the server administrator or Bitrix24 technical support
`500`	`ERROR_UNEXPECTED_ANSWER` Server returned an unexpected response	The server returned an unexpected response. Retry the call, and if the error persists, contact the server administrator or Bitrix24 technical support
`503`	`QUERY_LIMIT_EXCEEDED` Too many requests	The request intensity limit has been exceeded
`429`	`OPERATION_TIME_LIMIT` Method is blocked due to operation time limit	The method is blocked because the request resource intensity limit has been exceeded. The block is lifted automatically once the accumulated execution time of the method no longer exceeds the limit
`401`	`NO_AUTH_FOUND` Wrong authorization data	The request contains no authorization data: neither an access token nor a webhook code was passed
`401`	`INVALID_REQUEST` Https required	Methods are called over the HTTPS protocol only
`401`	`OVERLOAD_LIMIT` REST API is blocked due to overload	The REST API is blocked due to overload. This is a manual individual block. To have it lifted, contact Bitrix24 technical support
`401`	`ACCESS_DENIED` REST is available only on commercial plans	REST API access is not active for this account. In Bitrix24 Cloud, check the current plan or trial status: Vibe+ plans include REST API access, while Essentials plans do not. A webhook receives a different error message — `REST is available only by subscription`
`401`	`INVALID_CREDENTIALS` Invalid request credentials	No active webhook with the specified user identifier and secret code was found
`404`	`ERROR_METHOD_NOT_FOUND` Method not found!	No method with this name was found. The name is misspelled, the method does not exist in the REST API, or it is unavailable without the required scope
`401`	`insufficient_scope` The request requires higher privileges than provided by the webhook token	The request requires broader permissions than the token has: for a webhook these are the permissions granted to it, for an application it is the scope. For an application, the error message ends with `provided by the access token`
`401`	`expired_token` The access token provided has expired	The access token has expired
`401`	`user_access_error` The user does not have access to the application	The application is installed, but the Bitrix24 administrator has granted access to it only to specific users
`403`	`PORTAL_DELETED` Portal was deleted	The public part of the site is closed. To open it on an on-premise installation, disable the "Temporary closure of the public part of the site" option. Path to the setting: Desktop > Settings > Product Settings > Module Settings > Main Module > Temporary closure of the public part of the site

Continue Learning

Was the article helpful?

Get Block by ID

Get Block Manifest from Repository

Get the Manifest of the landing.block.getmanifest Method

Method ParametersMethod Parameters

Parameter paramsParameter params

Code ExamplesCode Examples

Response HandlingResponse Handling

Returned DataReturned Data

Object resultObject result

Object blockObject block

Object assetsObject assets

Error HandlingError Handling

Possible Error CodesPossible Error Codes

Statuses and System Error CodesStatuses and System Error Codes

Continue LearningContinue Learning