Copy Block to Page landing.landing.copyblock

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 "edit" access permission for the site

The method landing.landing.copyblock copies a block to the specified page and returns the identifier of the created copy of the block. You can copy a block from another page or within the same page. The HTML content of the block is also copied.

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`	Identifier of the page to which the block should be copied. The page identifier can be obtained using the method landing.landing.getList, as well as from the results of the methods landing.landing.add, landing.landing.addByTemplate, and landing.landing.copy
block* `integer`	Identifier of the source block. The block identifier can be obtained using the method landing.block.getList. The block can be located on another page or on the same page `lid`. You can only copy an existing block that is not marked as deleted. If the block is deleted, the method will return an error
params `object`	Additional copy parameters (detailed description)

Parameter params

Name
type

Description

AFTER_ID
integer

Identifier of the block on the page lid, after which the copy should be inserted.

If you pass the identifier of an existing block on the page lid, the copy will be inserted immediately after it. If the parameter is not passed, or if you pass 0 or specify the identifier of a block that does not exist on the page lid, the copy will be added to the end of the page

RETURN_CONTENT
string

If you pass Y, the method will return an object with a success indicator and data of the created copy of the block (detailed description). For any other value, the method will return only the identifier of the created copy of the block

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": 351,
            "block": 6428,
            "params": {
              "AFTER_ID": 6429,
              "RETURN_CONTENT": "Y"
            }
          }' \
          "https://**put.your-domain-here**/rest/**user_id**/**webhook_code**/landing.landing.copyblock.json"

curl -X POST \
          -H "Content-Type: application/json" \
          -d '{
            "lid": 351,
            "block": 6428,
            "params": {
              "AFTER_ID": 6429,
              "RETURN_CONTENT": "Y"
            },
            "auth": "**put_access_token_here**"
          }' \
          "https://**put.your-domain-here**/rest/landing.landing.copyblock.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 CopyBlockResult = {
          result: boolean
          content: {
            id: number
            sections: string
            active: boolean
            access: string
            anchor: string
            php: boolean
            designed: boolean
            repoId: number | null
            content: string
            content_ext: string
            css: string[]
            js: string[]
            assetStrings: string[]
            lang: string[] | Record<string, string>
            manifest: Record<string, unknown>
            dynamicParams: unknown[]
          }
        }
        
        try {
          const response = await $b24.actions.v2.call.make<CopyBlockResult>({
            method: 'landing.landing.copyblock',
            params: {
              lid: 351,
              block: 6428,
              params: {
                AFTER_ID: 6429,
                RETURN_CONTENT: 'Y',
              },
            },
            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.result, result.content.id, result.content.anchor)
          }
        } 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 copyBlock() {
            try {
              // Initialize the SDK inside a Bitrix24 frame
              const $b24 = await B24Js.initializeB24Frame()
        
              const response = await $b24.actions.v2.call.make({
                method: 'landing.landing.copyblock',
                params: {
                  lid: 351,
                  block: 6428,
                  params: {
                    AFTER_ID: 6429,
                    RETURN_CONTENT: 'Y',
                  },
                },
                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.result, result.content.id, result.content.anchor)
            } catch (error) {
              // Thrown on transport or SDK failures (AjaxError, SdkError, etc.)
              console.error(error)
            }
          }
        
          document.addEventListener('DOMContentLoaded', copyBlock)
        </script>

from b24pysdk.errors import BitrixAPIError, BitrixSDKException
        
        try:
            bitrix_response = client.landing.landing.copyblock(
                lid=351,
                block=6428,
                params={
                    "AFTER_ID": 6429,
                    "RETURN_CONTENT": "Y",
                },
            ).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.landing.copyblock',
                    [
                        'lid' => 351,
                        'block' => 6428,
                        'params' => [
                            'AFTER_ID' => 6429,
                            'RETURN_CONTENT' => 'Y',
                        ],
                    ]
                );
        
            $result = $response
                ->getResponseData()
                ->getResult();
        
            print_r($result);
        } catch (Throwable $e) {
            error_log($e->getMessage());
            echo 'Error: ' . $e->getMessage();
        }

BX24.callMethod(
            'landing.landing.copyblock',
            {
                lid: 351,
                block: 6428,
                params: {
                    AFTER_ID: 6429,
                    RETURN_CONTENT: 'Y'
                }
            },
            function(result)
            {
                if (result.error())
                {
                    console.error(result.error());
                }
                else
                {
                    console.info(result.data());
                }
            }
        );

require_once('crest.php');
        
        $result = CRest::call(
            'landing.landing.copyblock',
            [
                'lid' => 351,
                'block' => 6428,
                'params' => [
                    'AFTER_ID' => 6429,
                    'RETURN_CONTENT' => 'Y',
                ],
            ]
        );
        
        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.landing.copyblock", b24.Params{
        	"lid":   351,
        	"block": 6428,
        	"params": b24.Params{
        		"AFTER_ID":       6429,
        		"RETURN_CONTENT": "Y",
        	},
        })
        if err != nil {
        	return fmt.Errorf("landing.landing.copyblock: %w", err)
        }
        
        var value b24.ID
        if err := json.Unmarshal(res.Result, &value); err != nil {
        	return fmt.Errorf("parse response: %w", err)
        }
        fmt.Println("result:", value)

Response Handling

HTTP Status: 200

{
            "result": 28607,
            "time": {
                "start": 1773932480,
                "finish": 1773932480.485875,
                "duration": 0.48587489128112793,
                "processing": 0,
                "date_start": "2026-03-19T18:01:20+01:00",
                "date_finish": "2026-03-19T18:01:20+01:00",
                "operating_reset_at": 1773933080,
                "operating": 0
            }
        }

If params.RETURN_CONTENT = 'Y' is passed, instead of the block identifier, the method will return an object with a success indicator and data of the created copy of the block.

Example Response when `RETURN_CONTENT = 'Y'`

{
            "result": {
                "result": true,
                "content": {
                    "id": 28607,
                    "sections": "text_image,about",
                    "active": true,
                    "access": "X",
                    "anchor": "b28607",
                    "php": false,
                    "designed": false,
                    "repoId": null,
                    "content": "<div id=\"block28607\" data-id=\"28607\" class=\"block-wrapper block-19-2-features-with-img\">...</div>",
                    "content_ext": "",
                    "css": [],
                    "js": [
                        "/bitrix/js/pull/protobuf/protobuf.js?1592315491274055",
                        "/bitrix/js/pull/protobuf/model.min.js?159231549114190",
                        "/bitrix/js/main/core/core_promise.min.js?17647596972494",
                        "/bitrix/js/rest/client/rest.client.min.js?16015491189240",
                        "/bitrix/js/pull/client/pull.client.min.js?174471771449849"
                    ],
                    "assetStrings": [],
                    "lang": [],
                    "manifest": {
                        "block": {
                            "name": "Text with Icon Points and Image on the Left",
                            "section": [
                                "text_image",
                                "about"
                            ]
                        },
                        "timestamp": 1751467642,
                        "namespace": "bitrix",
                        "code": "19.2.features_with_img",
                        "preview": "/bitrix/blocks/bitrix/19.2.features_with_img/preview.jpg"
                    },
                    "dynamicParams": []
                }
            },
            "time": {
                "start": 1773933164,
                "finish": 1773933164.48191,
                "duration": 0.48190999031066895,
                "processing": 0,
                "date_start": "2026-03-19T18:12:44+01:00",
                "date_finish": "2026-03-19T18:12:44+01:00",
                "operating_reset_at": 1773933764,
                "operating": 0
            }
        }

Returned Data

Name `type`	Description
result `integer` \| `object`	Identifier of the created copy of the block. If `params.RETURN_CONTENT = 'Y'` is passed, the method will return an object with a success indicator and block data (detailed description)
time `time`	Information about the execution time of the request

Object result when `RETURN_CONTENT = 'Y'`

Name `type`	Description
result `boolean`	Indicator of successful copying. Returns `true` upon successful execution
content `object`	Data of the created copy of the block (detailed description)

Object content

Name `type`	Description
id `integer`	Identifier of the created copy of the block
sections `string`	Codes of the block sections from the manifest, concatenated into a single string separated by commas
active `boolean`	Indicator of the block's activity
access `string`	Access level to the block. Possible values: `A` — access closed to all blocks, `D` — access denied, `V` — can edit only design, `W` — can edit content and design without deletion, `X` — full access
anchor `string`	Local anchor of the block. The new block always receives an anchor of the form `b<ID>`, for example `b28607`
php `boolean`	Indicator that there is PHP code in the block's content
designed `boolean`	Indicator of a designed block
repoId `integer`	Identifier of the REST block from the repository or `null` if the block is not linked to a REST repository
content `string`	Prepared HTML code of the block
content_ext `string`	Additional HTML code of connected extensions
css `array`	List of CSS resources for the block. If there are no separate CSS connections for the block, an empty array is returned
js `array`	List of JS resources for the block and related client libraries that need to be included for its operation. For REST blocks of the type `repo_<ID>`, this field returns an empty array
assetStrings `array`	Initialization strings for resources that need to be added to the page
lang `array` \| `object`	Language messages of connected extensions. If messages exist, the field is returned as a key-value object. If there are no additional messages, it may return an empty array
manifest `object`	The complete manifest of the block. The format is described in the section Block Manifest
dynamicParams `array`	Parameters of the dynamic block from `SOURCE_PARAMS`. For regular static blocks, this field usually returns an empty array
requiredUserAction `array`	The field contains the same data as `manifest.requiredUserAction`. It is returned only when the user must perform additional action on the client side after copying the block

Error Handling

HTTP Status: 400 Bad Request

{
            "error": "BLOCK_NOT_FOUND",
            "error_description": "Block not found in the landing"
        }

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 not provided
`LANDING_NOT_EXIST`	The page with identifier `lid` is not found or is not accessible to the current user
`ACCESS_DENIED`	The user does not have permission to call landing methods or does not have permission to edit the page `lid`
`BLOCK_NOT_FOUND`	The source block with identifier `block` is not found, is not accessible to the current user, is marked as deleted, or cannot be loaded from the source page

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?

Add Block to Page

Remove Block from Page

Copy Block to Page landing.landing.copyblock

Method ParametersMethod Parameters

Parameter paramsParameter params

Code ExamplesCode Examples

Response HandlingResponse Handling

Example Response when Example Response when RETURN_CONTENT = 'Y'

Returned DataReturned Data

Object result whenObject result when RETURN_CONTENT = 'Y'

Object contentObject content

Error HandlingError Handling

Possible Error CodesPossible Error Codes

Statuses and System Error CodesStatuses and System Error Codes

Continue LearningContinue Learning