How to Add a Product with Custom Property Values

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Core\Exceptions\BaseException;
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Monolog\Handler\StreamHandler;
        use Monolog\Logger;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        
        $log = new Logger('b24');
        $log->pushHandler(new StreamHandler('php://stdout'));
        
        $b24 = (new ServiceBuilderFactory(new EventDispatcher(), $log))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        $iblockId = 23;
        
        function addProperty($b24, array $fields): array
        {
            return $b24->core->call('catalog.productProperty.add', ['fields' => $fields])
                ->getResponseData()
                ->getResult()['productProperty'];
        }
        
        function addPropertyEnum($b24, int $propertyId, string $value, string $xmlId, int $sort): array
        {
            return $b24->core->call(
                'catalog.productPropertyEnum.add',
                [
                    'fields' => [
                        'propertyId' => $propertyId,
                        'value' => $value,
                        'xmlId' => $xmlId,
                        'sort' => $sort,
                    ],
                ]
            )->getResponseData()->getResult()['productPropertyEnum'];
        }
        
        try
        {
            $colorProperty = addProperty($b24, [
                'iblockId' => $iblockId,
                'name' => 'Color',
                'code' => 'COLOR',
                'propertyType' => 'L',
                'listType' => 'L',
                'multiple' => 'N',
                'active' => 'Y',
                'sort' => 100,
            ]);
        
            $sizeProperty = addProperty($b24, [
                'iblockId' => $iblockId,
                'name' => 'Sizes',
                'code' => 'SIZES',
                'propertyType' => 'L',
                'listType' => 'C',
                'multiple' => 'Y',
                'active' => 'Y',
                'sort' => 200,
            ]);
        
            $certificateProperty = addProperty($b24, [
                'iblockId' => $iblockId,
                'name' => 'Certificate',
                'code' => 'CERTIFICATE',
                'propertyType' => 'F',
                'multiple' => 'N',
                'active' => 'Y',
                'sort' => 300,
            ]);
        
            $galleryProperty = addProperty($b24, [
                'iblockId' => $iblockId,
                'name' => 'Gallery',
                'code' => 'GALLERY',
                'propertyType' => 'F',
                'multiple' => 'Y',
                'active' => 'Y',
                'sort' => 400,
            ]);
        
            $colorBlue = addPropertyEnum($b24, $colorProperty['id'], 'Blue', 'BLUE', 100);
            $colorRed = addPropertyEnum($b24, $colorProperty['id'], 'Red', 'RED', 200);
            $sizeM = addPropertyEnum($b24, $sizeProperty['id'], 'M', 'M', 100);
            $sizeL = addPropertyEnum($b24, $sizeProperty['id'], 'L', 'L', 200);
        
            print_r([
                'colorPropertyId' => $colorProperty['id'],
                'colorBlueId' => $colorBlue['id'],
                'colorRedId' => $colorRed['id'],
                'sizePropertyId' => $sizeProperty['id'],
                'sizeValueIds' => [
                    $sizeM['id'],
                    $sizeL['id'],
                ],
                'certificatePropertyId' => $certificateProperty['id'],
                'galleryPropertyId' => $galleryProperty['id'],
            ]);
        }
        catch (BaseException $exception)
        {
            echo 'Error: '.$exception->getMessage();
        }
        ?>
        

# pip install b24pysdk
        from b24pysdk import BitrixWebhook, Client
        from b24pysdk.errors import BitrixAPIError
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        
        iblock_id = 23
        
        def add_property(fields):
            return client.catalog.product_property.add(fields=fields).response.result["productProperty"]
        
        def add_property_enum(property_id, value, xml_id, sort):
            return client.catalog.product_property_enum.add(
                fields={
                    "propertyId": property_id,
                    "value": value,
                    "xmlId": xml_id,
                    "sort": sort,
                },
            ).response.result["productPropertyEnum"]
        
        try:
            color_property = add_property({
                "iblockId": iblock_id,
                "name": "Color",
                "code": "COLOR",
                "propertyType": "L",
                "listType": "L",
                "multiple": "N",
                "active": "Y",
                "sort": 100,
            })
        
            size_property = add_property({
                "iblockId": iblock_id,
                "name": "Sizes",
                "code": "SIZES",
                "propertyType": "L",
                "listType": "C",
                "multiple": "Y",
                "active": "Y",
                "sort": 200,
            })
        
            certificate_property = add_property({
                "iblockId": iblock_id,
                "name": "Certificate",
                "code": "CERTIFICATE",
                "propertyType": "F",
                "multiple": "N",
                "active": "Y",
                "sort": 300,
            })
        
            gallery_property = add_property({
                "iblockId": iblock_id,
                "name": "Gallery",
                "code": "GALLERY",
                "propertyType": "F",
                "multiple": "Y",
                "active": "Y",
                "sort": 400,
            })
        
            color_blue = add_property_enum(color_property["id"], "Blue", "BLUE", 100)
            color_red = add_property_enum(color_property["id"], "Red", "RED", 200)
            size_m = add_property_enum(size_property["id"], "M", "M", 100)
            size_l = add_property_enum(size_property["id"], "L", "L", 200)
        
        except BitrixAPIError as error:
            print(f"Error: {error}")
        
        else:
            print({
                "colorPropertyId": color_property["id"],
                "colorBlueId": color_blue["id"],
                "colorRedId": color_red["id"],
                "sizePropertyId": size_property["id"],
                "sizeValueIds": [size_m["id"], size_l["id"]],
                "certificatePropertyId": certificate_property["id"],
                "galleryPropertyId": gallery_property["id"],
            })
        

// The symbolic code of a property is unique within an information block, while the xmlId of a value is
        // within its own property. A fresh suffix on every run avoids
        // a duplicate error if the previous run did not manage to clean up after itself.
        suffix := strconv.FormatInt(time.Now().Unix(), 36)
        
        // A list property needs AT LEAST TWO values. With one, Bitrix24 treats
        // the property as a "Yes/No" type, and a value ID cannot be written into it:
        // the product returns property N equal to "N", and without an error.
        color, err := addListProperty(ctx, core, iblockID, "Color", "COLOR_"+suffix, "N",
        	[]enumValue{{"Blue", "BLUE_" + suffix}, {"Red", "RED_" + suffix}})
        if err != nil {
        	return err
        }
        defer deleteProperty(ctx, core, color)
        
        sizes, err := addListProperty(ctx, core, iblockID, "Sizes", "SIZES_"+suffix, "Y",
        	[]enumValue{{"M", "M_" + suffix}, {"L", "L_" + suffix}})
        if err != nil {
        	return err
        }
        defer deleteProperty(ctx, core, sizes)
        
        certificate, err := addFileProperty(ctx, core, iblockID, "Certificate", "CERTIFICATE_"+suffix, "N")
        if err != nil {
        	return err
        }
        defer deleteProperty(ctx, core, certificate)
        
        gallery, err := addFileProperty(ctx, core, iblockID, "Gallery", "GALLERY_"+suffix, "Y")
        if err != nil {
        	return err
        }
        defer deleteProperty(ctx, core, gallery)
        

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Core\Exceptions\BaseException;
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Monolog\Handler\StreamHandler;
        use Monolog\Logger;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        
        $log = new Logger('b24');
        $log->pushHandler(new StreamHandler('php://stdout'));
        
        $b24 = (new ServiceBuilderFactory(new EventDispatcher(), $log))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        $iblockId = 23;
        $colorPropertyId = 431;
        $colorBlueId = 1739;
        $sizePropertyId = 432;
        $sizeValueIds = [1741, 1742];
        $certificatePropertyId = 433;
        $galleryPropertyId = 434;
        
        function encodeFile(string $path): array
        {
            if (!file_exists($path))
            {
                throw new RuntimeException('File not found: '.$path);
            }
        
            return [
                basename($path),
                base64_encode(file_get_contents($path)),
            ];
        }
        
        try
        {
            $fields = [
                'iblockId' => $iblockId,
                'name' => 'Printed T-shirt',
                'active' => 'Y',
                'sort' => 100,
                'property'.$colorPropertyId => $colorBlueId,
                'property'.$sizePropertyId => $sizeValueIds,
                'property'.$certificatePropertyId => [
                    'value' => [
                        'fileData' => encodeFile('pictures/certificate.pdf'),
                    ],
                ],
                'property'.$galleryPropertyId => [
                    [
                        'value' => [
                            'fileData' => encodeFile('pictures/gallery-1.jpg'),
                        ],
                    ],
                    [
                        'value' => [
                            'fileData' => encodeFile('pictures/gallery-2.jpg'),
                        ],
                    ],
                ],
            ];
        
            $productId = $b24->getCatalogScope()->product()->add($fields)->product()->id;
        
            echo 'Product added: '.$productId;
        }
        catch (BaseException|RuntimeException $exception)
        {
            echo 'Error: '.$exception->getMessage();
        }
        ?>
        

# pip install b24pysdk
        import base64
        
        from b24pysdk import BitrixWebhook, Client
        from b24pysdk.errors import BitrixAPIError
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        
        iblock_id = 23
        color_property_id = 431
        color_blue_id = 1739
        size_property_id = 432
        size_value_ids = [1741, 1742]
        certificate_property_id = 433
        gallery_property_id = 434
        
        def encode_file(path):
            with open(path, "rb") as file:
                return [path.split("/")[-1], base64.b64encode(file.read()).decode()]
        
        fields = {
            "iblockId": iblock_id,
            "name": "Printed T-shirt",
            "active": "Y",
            "sort": 100,
            f"property{color_property_id}": color_blue_id,
            f"property{size_property_id}": size_value_ids,
            f"property{certificate_property_id}": {
                "value": {
                    "fileData": encode_file("pictures/certificate.pdf"),
                },
            },
            f"property{gallery_property_id}": [
                {
                    "value": {
                        "fileData": encode_file("pictures/gallery-1.jpg"),
                    },
                },
                {
                    "value": {
                        "fileData": encode_file("pictures/gallery-2.jpg"),
                    },
                },
            ],
        }
        
        try:
            element = client.catalog.product.add(fields=fields).response.result["element"]
        except BitrixAPIError as error:
            print(f"Error: {error}")
        else:
            print(f"Product added: {element['id']}")
        

// The name of the field holding the property value is built on the fly: propertyN, where N is
        // the property ID issued by the portal. That is why fields is a map into
        // which the keys are placed by a computed name, rather than a struct with tags.
        fields := b24.Params{
        	"iblockId": iblockID,
        	"name":     "Printed T-shirt",
        	"active":   "Y",
        	"sort":     100,
        }
        // A single list property is a value ID as a scalar.
        fields[propertyKey(color.ID)] = color.ValueIDs[0]
        // A multiple list field is an array of value IDs.
        fields[propertyKey(sizes.ID)] = sizes.ValueIDs
        // A file property is an object with fileData: [file name, base64].
        fields[propertyKey(certificate.ID)] = fileValue("certificate.pdf",
        	[]byte("%PDF-1.4\nCertificate of conformity (b24gosdk example)\n"))
        // A multiple file field is an array of such objects.
        fields[propertyKey(gallery.ID)] = []any{
        	fileValue("gallery-1.jpg", []byte("first gallery image")),
        	fileValue("gallery-2.jpg", []byte("second gallery image")),
        }
        
        res, err := core.Call(ctx, "catalog.product.add", b24.Params{"fields": fields})
        if err != nil {
        	return fmt.Errorf("catalog.product.add: %w", err)
        }
        
        // add responds with the element key, while get responds with the product key for the same entity.
        raw, ok := b24.Unwrap(res.Result, "element", "id")
        if !ok {
        	return fmt.Errorf("no element.id in %s", res.Result)
        }
        var productID b24.ID
        if err := json.Unmarshal(raw, &productID); err != nil {
        	return fmt.Errorf("parse product ID: %w", err)
        }
        

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Core\Exceptions\BaseException;
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Monolog\Handler\StreamHandler;
        use Monolog\Logger;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        
        $log = new Logger('b24');
        $log->pushHandler(new StreamHandler('php://stdout'));
        
        $b24 = (new ServiceBuilderFactory(new EventDispatcher(), $log))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        $productId = 1267;
        $catalogGroupId = 1;
        
        try
        {
            $price = $b24->core->call(
                'catalog.price.add',
                [
                    'fields' => [
                        'productId' => $productId,
                        'catalogGroupId' => $catalogGroupId,
                        'price' => 4900,
                        'currency' => 'EUR',
                    ],
                ]
            )->getResponseData()->getResult()['price'];
        
            echo 'Price added: '.$price['id'];
        }
        catch (BaseException $exception)
        {
            echo 'Error: '.$exception->getMessage();
        }
        ?>
        

# pip install b24pysdk
        from b24pysdk import BitrixWebhook, Client
        from b24pysdk.errors import BitrixAPIError
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        
        product_id = 1267
        catalog_group_id = 1
        
        try:
            price = client.catalog.price.add(
                fields={
                    "productId": product_id,
                    "catalogGroupId": catalog_group_id,
                    "price": 4900,
                    "currency": "EUR",
                },
            ).response.result["price"]
        except BitrixAPIError as error:
            print(f"Error: {error}")
        else:
            print(f"Price added: {price['id']}")
        

// Setup in an empty directory — go get will not work without go mod init:
        //
        //	go mod init example && go get github.com/bitrix24/b24gosdk
        //
        // Run:
        //
        //	export B24_WEBHOOK_URL='https://your-portal.bitrix24.com/rest/1/token/' && go run .
        //
        // The example goes through all three steps of the page: it creates the properties and list values,
        // adds a product with property values and files, adds a price, displays
        // the result and cleans up after itself. The files are not read from disk — the example generates
        // their content itself, so it runs on any portal, and nothing needs to be edited or
        // prepared.
        package main
        
        import (
        	"context"
        	"encoding/base64"
        	"encoding/json"
        	"fmt"
        	"log"
        	"os"
        	"strconv"
        	"time"
        
        	b24 "github.com/bitrix24/b24gosdk"
        )
        
        func main() {
        	if err := run(context.Background()); err != nil {
        		log.Fatal(err)
        	}
        }
        
        func run(ctx context.Context) error {
        	// The webhook path is a secret, so it comes from the environment, not from the code.
        	core := b24.NewClient(os.Getenv("B24_WEBHOOK_URL")).Core()
        
        	iblockID, err := firstCatalog(ctx, core)
        	if err != nil {
        		return err
        	}
        	priceTypeID, err := firstPriceType(ctx, core)
        	if err != nil {
        		return err
        	}
        
        	// --- step 1: the properties and the values of their lists
        	// The symbolic code of a property is unique within an information block, while the xmlId of a value is
        	// within its own property. A fresh suffix on every run avoids
        	// a duplicate error if the previous run did not manage to clean up after itself.
        	suffix := strconv.FormatInt(time.Now().Unix(), 36)
        
        	// A list property needs AT LEAST TWO values. With one, Bitrix24 treats
        	// the property as a "Yes/No" type, and a value ID cannot be written into it:
        	// the product returns property N equal to "N", and without an error.
        	color, err := addListProperty(ctx, core, iblockID, "Color", "COLOR_"+suffix, "N",
        		[]enumValue{{"Blue", "BLUE_" + suffix}, {"Red", "RED_" + suffix}})
        	if err != nil {
        		return err
        	}
        	defer deleteProperty(ctx, core, color)
        
        	sizes, err := addListProperty(ctx, core, iblockID, "Sizes", "SIZES_"+suffix, "Y",
        		[]enumValue{{"M", "M_" + suffix}, {"L", "L_" + suffix}})
        	if err != nil {
        		return err
        	}
        	defer deleteProperty(ctx, core, sizes)
        
        	certificate, err := addFileProperty(ctx, core, iblockID, "Certificate", "CERTIFICATE_"+suffix, "N")
        	if err != nil {
        		return err
        	}
        	defer deleteProperty(ctx, core, certificate)
        
        	gallery, err := addFileProperty(ctx, core, iblockID, "Gallery", "GALLERY_"+suffix, "Y")
        	if err != nil {
        		return err
        	}
        	defer deleteProperty(ctx, core, gallery)
        	fmt.Printf("properties: Color=%d %v, Sizes=%d %v, Certificate=%d, Gallery=%d\n",
        		color.ID, color.ValueIDs, sizes.ID, sizes.ValueIDs, certificate.ID, gallery.ID)
        
        	// --- step 2: a product with property values
        	// The name of the field holding the property value is built on the fly: propertyN, where N is
        	// the property ID issued by the portal. That is why fields is a map into
        	// which the keys are placed by a computed name, rather than a struct with tags.
        	fields := b24.Params{
        		"iblockId": iblockID,
        		"name":     "Printed T-shirt",
        		"active":   "Y",
        		"sort":     100,
        	}
        	// A single list property is a value ID as a scalar.
        	fields[propertyKey(color.ID)] = color.ValueIDs[0]
        	// A multiple list field is an array of value IDs.
        	fields[propertyKey(sizes.ID)] = sizes.ValueIDs
        	// A file property is an object with fileData: [file name, base64].
        	fields[propertyKey(certificate.ID)] = fileValue("certificate.pdf",
        		[]byte("%PDF-1.4\nCertificate of conformity (b24gosdk example)\n"))
        	// A multiple file field is an array of such objects.
        	fields[propertyKey(gallery.ID)] = []any{
        		fileValue("gallery-1.jpg", []byte("first gallery image")),
        		fileValue("gallery-2.jpg", []byte("second gallery image")),
        	}
        
        	res, err := core.Call(ctx, "catalog.product.add", b24.Params{"fields": fields})
        	if err != nil {
        		return fmt.Errorf("catalog.product.add: %w", err)
        	}
        
        	// add responds with the element key, while get responds with the product key for the same entity.
        	raw, ok := b24.Unwrap(res.Result, "element", "id")
        	if !ok {
        		return fmt.Errorf("no element.id in %s", res.Result)
        	}
        	var productID b24.ID
        	if err := json.Unmarshal(raw, &productID); err != nil {
        		return fmt.Errorf("parse product ID: %w", err)
        	}
        	defer del(ctx, core, "catalog.product.delete", b24.Params{"id": productID})
        	fmt.Printf("product %d created\n", productID)
        
        	// --- step 3: the product price
        
        	// catalog.product.add does not set the price: the product card and its prices are different
        	// methods.
        	res, err = core.Call(ctx, "catalog.price.add", b24.Params{
        		"fields": b24.Params{
        			"productId":      productID,
        			"catalogGroupId": priceTypeID,
        			"price":          4900,
        			"currency":       "EUR",
        		},
        	})
        	if err != nil {
        		return fmt.Errorf("catalog.price.add: %w", err)
        	}
        	var price struct {
        		Price struct {
        			ID       b24.ID  `json:"id"`
        			Price    float64 `json:"price"`
        			Currency string  `json:"currency"`
        		} `json:"price"`
        	}
        	if err := json.Unmarshal(res.Result, &price); err != nil {
        		return fmt.Errorf("parse price: %w", err)
        	}
        
        	fmt.Printf("price %d: %.0f %s\n", price.Price.ID, price.Price.Price, price.Price.Currency)
        	return showProduct(ctx, core, productID, color.ID, sizes.ID)
        }
        
        // --- helpers: properties, files, verification, and cleanup
        
        // propertyKey builds the name of the field holding the property value: property431.
        func propertyKey(propertyID b24.ID) string {
        	return "property" + strconv.FormatInt(int64(propertyID), 10)
        }
        
        // fileValue packs a file the way a product file property accepts it.
        // Files travel as base64 INSIDE the JSON — multipart is not needed here.
        func fileValue(name string, content []byte) b24.Params {
        	return b24.Params{
        		"value": b24.Params{
        			"fileData": []string{name, base64.StdEncoding.EncodeToString(content)},
        		},
        	}
        }
        
        type enumValue struct{ Value, XMLID string }
        
        // property is the created property together with the IDs of its list values.
        type property struct {
        	ID       b24.ID
        	Name     string
        	ValueIDs []b24.ID
        }
        
        func addListProperty(ctx context.Context, core *b24.Core, iblockID b24.ID,
        	name, code, multiple string, values []enumValue) (property, error) {
        	prop, err := addProperty(ctx, core, b24.Params{
        		"iblockId":     iblockID,
        		"name":         name,
        		"code":         code,
        		"propertyType": "L", // L — a list, its values are added by a separate method
        		"listType":     "L",
        		"multiple":     multiple,
        		"active":       "Y",
        	})
        	if err != nil {
        		return prop, err
        	}
        	for i, v := range values {
        		res, err := core.Call(ctx, "catalog.productPropertyEnum.add", b24.Params{
        			"fields": b24.Params{
        				"propertyId": prop.ID,
        				"value":      v.Value,
        				"xmlId":      v.XMLID,
        				"sort":       (i + 1) * 100,
        			},
        		})
        		if err != nil {
        			// The property is already created: return it together with the error so that
        			// the caller can clean up after itself.
        			return prop, fmt.Errorf("catalog.productPropertyEnum.add %s: %w", v.XMLID, err)
        		}
        		raw, ok := b24.Unwrap(res.Result, "productPropertyEnum", "id")
        		if !ok {
        			return prop, fmt.Errorf("no productPropertyEnum.id in %s", res.Result)
        		}
        		var id b24.ID
        		if err := json.Unmarshal(raw, &id); err != nil {
        			return prop, err
        		}
        		prop.ValueIDs = append(prop.ValueIDs, id)
        	}
        	return prop, nil
        }
        
        func addFileProperty(ctx context.Context, core *b24.Core, iblockID b24.ID,
        	name, code, multiple string) (property, error) {
        	return addProperty(ctx, core, b24.Params{
        		"iblockId":     iblockID,
        		"name":         name,
        		"code":         code,
        		"propertyType": "F", // F — a file
        		"multiple":     multiple,
        		"active":       "Y",
        	})
        }
        
        func addProperty(ctx context.Context, core *b24.Core, fields b24.Params) (property, error) {
        	res, err := core.Call(ctx, "catalog.productProperty.add", b24.Params{"fields": fields})
        	if err != nil {
        		return property{}, fmt.Errorf("catalog.productProperty.add %v: %w", fields["code"], err)
        	}
        	var out struct {
        		ProductProperty struct {
        			ID   b24.ID `json:"id"`
        			Name string `json:"name"`
        		} `json:"productProperty"`
        	}
        	if err := json.Unmarshal(res.Result, &out); err != nil {
        		return property{}, fmt.Errorf("parse property: %w", err)
        	}
        	return property{ID: out.ProductProperty.ID, Name: out.ProductProperty.Name}, nil
        }
        
        // showProduct reads the product back: file properties are returned as a link to
        // the uploaded file rather than the original base64 string.
        func showProduct(ctx context.Context, core *b24.Core, productID, colorID, sizesID b24.ID) error {
        	res, err := core.Call(ctx, "catalog.product.get",
        		b24.Params{"id": productID}, b24.WithIdempotent())
        	if err != nil {
        		return fmt.Errorf("catalog.product.get: %w", err)
        	}
        	for _, key := range []string{propertyKey(colorID), propertyKey(sizesID)} {
        		raw, ok := b24.Unwrap(res.Result, "product", key)
        		if !ok {
        			continue
        		}
        		// The same field arrives as an OBJECT for a single property and as an ARRAY
        		// for a multiple one — check the shape before unmarshalling.
        		fmt.Printf("  %s (%s): %s\n", key, b24.Result(raw).Kind(), raw)
        	}
        	return nil
        }
        
        func firstCatalog(ctx context.Context, core *b24.Core) (b24.ID, error) {
        	res, err := core.Call(ctx, "catalog.catalog.list", b24.Params{
        		"filter": b24.Params{"iblockTypeId": "CRM_PRODUCT_CATALOG"},
        	}, b24.WithIdempotent())
        	if err != nil {
        		return 0, fmt.Errorf("catalog.catalog.list: %w", err)
        	}
        	var out struct {
        		Catalogs []struct {
        			IblockID b24.ID `json:"iblockId"`
        		} `json:"catalogs"`
        	}
        	if err := json.Unmarshal(res.Result, &out); err != nil {
        		return 0, err
        	}
        	if len(out.Catalogs) == 0 {
        		return 0, fmt.Errorf("the portal has no commercial catalog")
        	}
        	return out.Catalogs[0].IblockID, nil
        }
        
        func firstPriceType(ctx context.Context, core *b24.Core) (b24.ID, error) {
        	res, err := core.Call(ctx, "catalog.priceType.list", nil, b24.WithIdempotent())
        	if err != nil {
        		return 0, fmt.Errorf("catalog.priceType.list: %w", err)
        	}
        	var out struct {
        		PriceTypes []struct {
        			ID b24.ID `json:"id"`
        		} `json:"priceTypes"`
        	}
        	if err := json.Unmarshal(res.Result, &out); err != nil {
        		return 0, err
        	}
        	if len(out.PriceTypes) == 0 {
        		return 0, fmt.Errorf("the portal has no price types")
        	}
        	return out.PriceTypes[0].ID, nil
        }
        
        // deleteProperty removes the list values together with the property.
        func deleteProperty(ctx context.Context, core *b24.Core, prop property) {
        	for _, id := range prop.ValueIDs {
        		del(ctx, core, "catalog.productPropertyEnum.delete", b24.Params{"id": id})
        	}
        	del(ctx, core, "catalog.productProperty.delete", b24.Params{"id": prop.ID})
        }
        
        // del removes what was created. A cleanup error is printed but not returned: it must not
        // mask the real error of the scenario.
        func del(ctx context.Context, core *b24.Core, method string, params b24.Params) {
        	if _, err := core.Call(ctx, method, params); err != nil {
        		fmt.Fprintf(os.Stderr, "cleanup, %s: %v