Add a Company with Requisites via Web Form

ar_address_fields = client.crm.address.fields().result
        ar_presets = client.crm.requisite.preset.list(select=["ID", "NAME"]).result
        

$arAddressFields = $sb->getCRMScope()->address()->fields()->getFieldsDescription();
        $arPresets = $sb->getCRMScope()->requisitePreset()->list(
            order: [], filter: [], select: ["ID", "NAME"]
        )->getRequisitePresets();
        

res, err := core.Call(ctx, "crm.address.fields", nil, b24.WithIdempotent())
        if err != nil {
        	return fmt.Errorf("crm.address.fields: %w", err)
        }
        
        // The response is not a list but an object "field name -> description", hence a map.
        var addressFields map[string]struct {
        	Type       string `json:"type"`
        	Title      string `json:"title"`
        	IsReadOnly bool   `json:"isReadOnly"`
        }
        if err := json.Unmarshal(res.Result, &addressFields); err != nil {
        	return fmt.Errorf("parsing address fields: %w", err)
        }
        
        res, err = core.Call(ctx, "crm.requisite.preset.list", b24.Params{
        	"select": []string{"ID", "NAME"},
        }, b24.WithIdempotent())
        if err != nil {
        	return fmt.Errorf("crm.requisite.preset.list: %w", err)
        }
        
        // Here the identifier arrives as a STRING ("1"), whereas crm.enum.* returns
        // numbers. b24.ID parses both notations.
        var presets []struct {
        	ID   b24.ID `json:"ID"`
        	Name string `json:"NAME"`
        }
        if err := json.Unmarshal(res.Result, &presets); err != nil {
        	return fmt.Errorf("parsing requisite templates: %w", err)
        }
        if len(presets) == 0 {
        	return fmt.Errorf("there are no requisite templates in Bitrix24")
        }
        

for f in ("TYPE_ID", "ENTITY_TYPE_ID", "ENTITY_ID", "COUNTRY_CODE", "ANCHOR_TYPE_ID", "ANCHOR_ID"):
            ar_address_fields.pop(f, None)
        

foreach (['TYPE_ID', 'ENTITY_TYPE_ID', 'ENTITY_ID', 'COUNTRY_CODE', 'ANCHOR_TYPE_ID', 'ANCHOR_ID'] as $field) {
            unset($arAddressFields[$field]);
        }
        

// The form takes only the string fields that are available for writing: TYPE_ID,
        // ENTITY_ID, and ENTITY_TYPE_ID also arrive in this response, but the handler
        // substitutes them itself. Map keys in Go are unordered — sort them, otherwise
        // the form fields will jump around from run to run.
        var addressNames []string
        for name, f := range addressFields {
        	if f.Type == "string" && !f.IsReadOnly {
        		addressNames = append(addressNames, name)
        	}
        }
        sort.Strings(addressNames)
        

# assemble the form string from the received data and insert it into the server response
        from markupsafe import escape
        
        options = "".join(
            f'<option value="{escape(preset["ID"])}">{escape(preset["NAME"])}</option>'
            for preset in ar_presets
        )
        address_inputs = "".join(
            f'<input type="text" name="ADDRESS[{escape(key)}]" '
            f'placeholder="{escape(field["title"])}" '
            f'{"required" if field["isRequired"] else ""}>'
            for key, field in ar_address_fields.items()
        )
        
        form_html = f"""
            <form id="form_to_crm">
                <select name="REQ_TYPE" required>
                    <option value="" disabled selected>Select a requisite type</option>
                    {options}
                </select>
                <input type="text" name="TITLE" placeholder="Org name" required>
                <input type="text" name="INN" placeholder="INN">
                <input type="text" name="PHONE" placeholder="Phone">
                {address_inputs}
                <input type="submit" value="Submit">
            </form>"""
        

<form id="form_to_crm">
            <select name="REQ_TYPE" required>
                <option value="" disabled selected>Select a requisite type</option>
                <?php foreach($arPresets as $preset):?>
                    <option value="<?=$preset->ID?>"><?=$preset->NAME?></option>
                <?php endforeach;?>
            </select>
            <input type="text" name="TITLE" placeholder="Org name" required>
            <input type="text" name="INN" placeholder="INN">
            <input type="text" name="PHONE" placeholder="Phone">
            <?php if(is_array($arAddressFields)):?>
                <?php foreach($arAddressFields as $key=>$arField):?>
                    <input type="text" name="ADDRESS[<?=$key?>]" placeholder="<?=$arField['title']?>" <?=($arField['isRequired'])?'required':'';?>>
                <?php endforeach;?>
            <?php endif;?>
            <input type="submit" value="Submit">
        </form>
        

var form strings.Builder
        form.WriteString(`<!doctype html>
        <meta charset="utf-8">
        <title>Request</title>
        <form method="post" action="/form">
        <p><label>Requisite type*<br><select name="REQ_TYPE" required>`)
        for _, p := range presets {
        	fmt.Fprintf(&form, `<option value="%d">%s</option>`, p.ID, html.EscapeString(p.Name))
        }
        form.WriteString(`</select></label></p>
        <p><label>Org name*<br><input name="TITLE" required></label></p>
        <p><label>INN<br><input name="INN"></label></p>
        <p><label>Phone<br><input name="PHONE" type="tel"></label></p>`)
        // The address fields are created dynamically: their set is defined by Bitrix24,
        // not by the code. Names such as ADDRESS[CITY] — the handler parses them back.
        for _, name := range addressNames {
        	fmt.Fprintf(&form, "<p><label>%s<br><input name=\"ADDRESS[%s]\"></label></p>\n",
        		html.EscapeString(addressFields[name].Title), name)
        }
        form.WriteString(`<p><button type="submit">Submit</button></p>
        </form>`)
        page := form.String()
        

# pip install b24pysdk flask
        import os
        
        from flask import Flask
        from markupsafe import escape
        from b24pysdk import BitrixWebhook, Client
        
        app = Flask(__name__)
        
        client = Client(BitrixWebhook(
            domain=os.environ["B24_DOMAIN"],  # your-domain.bitrix24.com
            webhook_token=os.environ["B24_TOKEN"],  # user_id/token only, without https://
        ))
        
        # Page template: %(options)s and %(address_inputs)s are substituted from Python
        PAGE = """
            <form id="form_to_crm">
                <select name="REQ_TYPE" required>
                    <option value="" disabled selected>Select a requisite type</option>
                    %(options)s
                </select>
                <input type="text" name="TITLE" placeholder="Org name" required>
                <input type="text" name="INN" placeholder="INN">
                <input type="text" name="PHONE" placeholder="Phone">
                %(address_inputs)s
                <input type="submit" value="Submit">
            </form>
            <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
            <script>
            $(document).ready(function() {
                $('#form_to_crm').on('submit', function(el) {
                    el.preventDefault();
                    $.ajax({
                        method: 'POST', dataType: 'json', url: '/form',
                        data: $(this).serialize(),
                        success: function(data) { alert(data.message); }
                    });
                });
            });
            </script>
        """
        
        EMPTY_PAGE = "<p>No requisite types available.</p>"
        
        
        @app.route("/")
        def form_page():
            # Retrieve the list of address fields and requisite templates
            ar_address_fields = client.crm.address.fields().result
            ar_presets = client.crm.requisite.preset.list(select=["ID", "NAME"]).result
        
            if not ar_presets:
                return EMPTY_PAGE
        
            # Remove system and unused address fields
            for f in ("TYPE_ID", "ENTITY_TYPE_ID", "ENTITY_ID", "COUNTRY_CODE", "ANCHOR_TYPE_ID", "ANCHOR_ID"):
                ar_address_fields.pop(f, None)
        
            # Assemble the requisite drop-down list and the address fields
            options = "".join(
                f'<option value="{escape(preset["ID"])}">{escape(preset["NAME"])}</option>'
                for preset in ar_presets
            )
            address_inputs = "".join(
                f'<input type="text" name="ADDRESS[{escape(key)}]" '
                f'placeholder="{escape(field["title"])}" '
                f'{"required" if field["isRequired"] else ""}>'
                for key, field in ar_address_fields.items()
            )
        
            return PAGE % {"options": options, "address_inputs": address_inputs}
        

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        use Psr\Log\NullLogger;
        
        $sb = (new ServiceBuilderFactory(new EventDispatcher(), new NullLogger()))
            ->initFromWebhook(getenv('B24_HOOK'));
        // B24_HOOK = 'https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/'
        
        // Retrieve the list of address fields and requisite templates
        $arAddressFields = $sb->getCRMScope()->address()->fields()->getFieldsDescription();
        $arPresets = $sb->getCRMScope()->requisitePreset()->list(
            order: [], filter: [], select: ["ID", "NAME"]
        )->getRequisitePresets();
        
        if(!empty($arPresets)):
            // Remove system and unused address fields
            $excludeFields = ['TYPE_ID', 'ENTITY_TYPE_ID', 'ENTITY_ID', 'COUNTRY_CODE', 'ANCHOR_TYPE_ID', 'ANCHOR_ID'];
            foreach($excludeFields as $field) {
                unset($arAddressFields[$field]);
            }
        ?>
            <form id="form_to_crm">
                <select name="REQ_TYPE" required>
                    <option value="" disabled selected>Select a requisite type</option>
                    <?php foreach($arPresets as $preset): ?>
                        <option value="<?=$preset->ID?>"><?=$preset->NAME?></option>
                    <?php endforeach; ?>
                </select>
                <input type="text" name="TITLE" placeholder="Org name" required>
                <input type="text" name="INN" placeholder="INN">
                <input type="text" name="PHONE" placeholder="Phone">
                <?php foreach($arAddressFields as $key => $arField): ?>
                    <input type="text" name="ADDRESS[<?=$key?>]"
                           placeholder="<?=$arField['title']?>"
                           <?=$arField['isRequired'] ? 'required' : ''?>>
                <?php endforeach; ?>
                <input type="submit" value="Submit">
            </form>
        <?php else: ?>
            <p>No requisite types available.</p>
        <?php endif; ?>
        
        <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
        <script>
        $(document).ready(function() {
            $('#form_to_crm').on('submit', function(el) {
                el.preventDefault();
                $.ajax({
                    method: 'POST',
                    dataType: 'json',
                    url: 'form.php', // handler file from step 2
                    data: $(this).serialize(),
                    success: function(data) {
                        alert(data.message);
                    }
                });
            });
        });
        </script>
        

// The full code of the page and the handler is in the example below, in step 2:
        // the same program assembles and serves the page, there is no separate file for
        // the form.
        mux := http.NewServeMux()
        mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        	w.Header().Set("Content-Type", "text/html; charset=utf-8")
        	fmt.Fprint(w, page)
        })
        mux.HandleFunc("/form", func(w http.ResponseWriter, r *http.Request) {
        	if r.Method != http.MethodPost {
        		reply(w, http.StatusMethodNotAllowed, "POST required", 0)
        		return
        	}
        	handleForm(w, r, core)
        })
        
        log.Println("form and handler: http://localhost:3000/")
        return http.ListenAndServe(":3000", mux)
        

i_requisite_preset_id = int(request.form.get("REQ_TYPE", 0))
        s_title = request.form.get("TITLE", "")
        s_inn = request.form.get("INN", "")
        s_phone = request.form.get("PHONE", "")
        ar_address = {k[len("ADDRESS["):-1]: v for k, v in request.form.to_dict().items()
                      if k.startswith("ADDRESS[")}
        

$iRequisitePresetID = intval($_POST["REQ_TYPE"] ?? 0);
        $sTitle = htmlspecialchars($_POST["TITLE"] ?? '');
        $sINN = htmlspecialchars($_POST["INN"] ?? '');
        $sPhone = htmlspecialchars($_POST["PHONE"] ?? '');
        $arAddress = [];
        foreach (($_POST["ADDRESS"] ?? []) as $key => $val) {
            $arAddress[$key] = htmlspecialchars($val);
        }
        

// The requisite type is converted to a number, the rest is cleared of HTML tags.
        // The tags are CUT OUT rather than escaped: escaping is needed when rendering to
        // the page, and because of it the CRM would receive "Weber & Son" instead of
        // "Weber & Son".
        presetID, _ := strconv.Atoi(r.PostFormValue("REQ_TYPE"))
        title := stripTags(r.PostFormValue("TITLE"))
        inn := stripTags(r.PostFormValue("INN"))
        phone := stripTags(r.PostFormValue("PHONE"))
        
        if presetID == 0 || title == "" {
        	reply(w, http.StatusBadRequest, "Fill in the requisite type and the name", 0)
        	return
        }
        
        // The address fields arrived with names such as ADDRESS[CITY] — parse them back.
        address := b24.Params{}
        for key, values := range r.PostForm {
        	if inner, ok := addressKey(key); ok && len(values) > 0 && values[0] != "" {
        		address[inner] = stripTags(values[0])
        	}
        }
        

ar_address["TYPE_ID"] = 1
        ar_address["ENTITY_TYPE_ID"] = 8
        

$arAddress['TYPE_ID'] = 1;
        $arAddress['ENTITY_TYPE_ID'] = 8;
        

// The handler substitutes the address type and the owner type itself: they are not in the form.
        address["TYPE_ID"] = addressTypeActual
        address["ENTITY_TYPE_ID"] = typeRequisite
        

ar_phone = [{"VALUE": s_phone, "VALUE_TYPE": "WORK"}] if s_phone else []
        

$arPhone = !empty($sPhone) ? [['VALUE' => $sPhone, 'VALUE_TYPE' => 'WORK']] : [];
        

// The phone number is retained as a multifield — a list of objects, even when
        // there is a single number. A row WITHOUT an ID adds a value; MultifieldAdd
        // assembles it for you.
        phones := []map[string]any{}
        if phone != "" {
        	phones = append(phones, b24.MultifieldAdd(phone, "WORK"))
        }
        

i_company_id = client.crm.company.add(fields={
            "TITLE": s_title,
            "COMPANY_TYPE": "CUSTOMER",
            "PHONE": ar_phone,
        }).result
        

$iCompanyID = $sb->getCRMScope()->company()->add([
            'TITLE' => $sTitle,
            'COMPANY_TYPE' => 'CUSTOMER',
            'PHONE' => $arPhone,
        ])->getId();
        

res, err := core.Call(ctx, "crm.company.add", b24.Params{
        	"fields": b24.Params{
        		"TITLE":        title,
        		"COMPANY_TYPE": "CUSTOMER",
        		"PHONE":        phones,
        	},
        }) // without WithIdempotent: a retry would create a second company
        if err != nil {
        	// The details go to the server log, they are not shown to the visitor.
        	log.Println("crm.company.add:", err)
        	reply(w, http.StatusBadGateway, "Failed to create the company", 0)
        	return
        }
        
        // There is no wrapper: result is the identifier of the new company right away.
        var companyID b24.ID
        if err := json.Unmarshal(res.Result, &companyID); err != nil {
        	log.Println("parsing the company identifier:", err)
        	reply(w, http.StatusBadGateway, "Failed to create the company", 0)
        	return
        }
        

i_requisite_id = client.crm.requisite.add(fields={
            "ENTITY_TYPE_ID": 4,
            "ENTITY_ID": i_company_id,
            "PRESET_ID": i_requisite_preset_id,
            "ACTIVE": "Y",
            "NAME": s_title,
            "RQ_INN": s_inn,
        }).result
        

$iRequisiteID = $sb->getCRMScope()->requisite()->add(
            entityId: $iCompanyID,
            entityTypeId: 4,
            requisitePresetId: $iRequisitePresetID,
            requisiteName: $sTitle,
            fields: ['ACTIVE' => 'Y', 'RQ_INN' => $sINN]
        )->getId();
        

res, err = core.Call(ctx, "crm.requisite.add", b24.Params{
        	"fields": b24.Params{
        		"ENTITY_TYPE_ID": typeCompany,
        		"ENTITY_ID":      companyID,
        		"PRESET_ID":      presetID,
        		"ACTIVE":         "Y",
        		"NAME":           title,
        		"RQ_INN":         inn,
        	},
        })
        if err != nil {
        	// The company has already been created, so this is no reason to answer
        	// "nothing worked": report that the requisites were not added and return the
        	// identifier.
        	log.Println("crm.requisite.add:", err)
        	reply(w, http.StatusOK, "The company was created, the requisites could not be added", companyID)
        	return
        }
        var requisiteID b24.ID
        if err := json.Unmarshal(res.Result, &requisiteID); err != nil {
        	log.Println("parsing the requisite identifier:", err)
        	reply(w, http.StatusOK, "The company was created, the requisites could not be added", companyID)
        	return
        }
        

# pip install b24pysdk flask
        import os
        
        from flask import Flask, request, jsonify
        from b24pysdk import BitrixWebhook, Client
        
        app = Flask(__name__)
        
        client = Client(BitrixWebhook(
            domain=os.environ["B24_DOMAIN"],  # your-domain.bitrix24.com
            webhook_token=os.environ["B24_TOKEN"],  # user_id/token only, without https://
        ))
        
        
        @app.route("/form", methods=["POST"])
        def handle_form():
            # Retrieve and sanitize the form data
            i_requisite_preset_id = int(request.form.get("REQ_TYPE", 0))
            s_title = request.form.get("TITLE", "")
            s_inn = request.form.get("INN", "")
            s_phone = request.form.get("PHONE", "")
        
            # Prepare the address
            ar_address = {k[len("ADDRESS["):-1]: v for k, v in request.form.to_dict().items()
                          if k.startswith("ADDRESS[")}
            ar_address["TYPE_ID"] = 1  # 1 — actual address (crm.enum.addresstype)
            ar_address["ENTITY_TYPE_ID"] = 8  # 8 — requisite (crm.enum.ownertype)
        
            # Format the phone number into the crm_multifield format
            ar_phone = [{"VALUE": s_phone, "VALUE_TYPE": "WORK"}] if s_phone else []
        
            try:
                i_company_id = client.crm.company.add(fields={
                    "TITLE": s_title,
                    "COMPANY_TYPE": "CUSTOMER",  # client (crm.status.list ENTITY_ID=COMPANY_TYPE)
                    "PHONE": ar_phone,
                }).result
        
                i_requisite_id = client.crm.requisite.add(fields={
                    "ENTITY_TYPE_ID": 4,  # 4 — company (crm.enum.ownertype)
                    "ENTITY_ID": i_company_id,
                    "PRESET_ID": i_requisite_preset_id,
                    "ACTIVE": "Y",
                    "NAME": s_title,
                    "RQ_INN": s_inn,
                }).result
        
                if i_requisite_id:
                    ar_address["ENTITY_ID"] = i_requisite_id
                    client.crm.address.add(fields=ar_address)
        
                return jsonify({"message": "The company has been added"})
            except Exception as e:
                return jsonify({"message": f"Error: {e}"})
        

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        use Psr\Log\NullLogger;
        
        $sb = (new ServiceBuilderFactory(new EventDispatcher(), new NullLogger()))
            ->initFromWebhook(getenv('B24_HOOK'));
        // B24_HOOK = 'https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/'
        $crm = $sb->getCRMScope();
        
        // Retrieve and sanitize the form data
        $iRequisitePresetID = intval($_POST["REQ_TYPE"] ?? 0);
        $sTitle = htmlspecialchars($_POST["TITLE"] ?? '');
        $sINN = htmlspecialchars($_POST["INN"] ?? '');
        $sPhone = htmlspecialchars($_POST["PHONE"] ?? '');
        
        // Prepare the address
        $arAddress = [];
        foreach(($_POST["ADDRESS"] ?? []) as $key => $val) {
            $arAddress[$key] = htmlspecialchars($val);
        }
        $arAddress['TYPE_ID'] = 1; // 1 — actual address (crm.enum.addresstype)
        $arAddress['ENTITY_TYPE_ID'] = 8; // 8 — requisite (crm.enum.ownertype)
        
        // Format the phone number into the crm_multifield format
        $arPhone = !empty($sPhone) ? [['VALUE' => $sPhone, 'VALUE_TYPE' => 'WORK']] : [];
        
        try {
            $iCompanyID = $crm->company()->add([
                'TITLE' => $sTitle,
                'COMPANY_TYPE' => 'CUSTOMER', // client (crm.status.list ENTITY_ID=COMPANY_TYPE)
                'PHONE' => $arPhone,
            ])->getId();
        
            $iRequisiteID = $crm->requisite()->add(
                entityId: $iCompanyID,
                entityTypeId: 4, // 4 — company (crm.enum.ownertype)
                requisitePresetId: $iRequisitePresetID,
                requisiteName: $sTitle,
                fields: ['ACTIVE' => 'Y', 'RQ_INN' => $sINN]
            )->getId();
        
            if (!empty($iRequisiteID)) {
                $arAddress['ENTITY_ID'] = $iRequisiteID;
                $crm->address()->add($arAddress);
            }
        
            echo json_encode(['message' => 'The company has been added']);
        } catch (\Throwable $e) {
            echo json_encode(['message' => 'Error: ' . $e->getMessage()]);
        }
        

// Preparation 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-domain.bitrix24.com/rest/1/token/' && go run .
        //
        // A separate file with the form is not needed: the same program assembles and
        // serves the page — it takes the address fields and the list of requisite
        // templates from Bitrix24. Open http://localhost:3000/
        package main
        
        import (
        	"context"
        	"encoding/json"
        	"fmt"
        	"html"
        	"log"
        	"net/http"
        	"os"
        	"regexp"
        	"sort"
        	"strconv"
        	"strings"
        
        	b24 "github.com/bitrix24/b24gosdk"
        )
        
        // CRM object type identifiers from crm.enum.ownertype.
        const (
        	typeCompany   = 4
        	typeRequisite = 8
        )
        
        // addressTypeActual — actual address; the full list of types is returned by
        // crm.enum.addresstype.
        const addressTypeActual = 1
        
        func main() {
        	if err := run(context.Background()); err != nil {
        		log.Fatal(err)
        	}
        }
        
        func run(ctx context.Context) error {
        	// The webhook URL is a secret: it comes from the environment, not from the
        	// code, and never ends up on the public page with the form. The client is
        	// built ONCE per Bitrix24: http.Server calls the handler from many goroutines.
        	core := b24.NewClient(os.Getenv("B24_WEBHOOK_URL")).Core()
        
        	// --- assemble the form from the Bitrix24 settings
        	res, err := core.Call(ctx, "crm.address.fields", nil, b24.WithIdempotent())
        	if err != nil {
        		return fmt.Errorf("crm.address.fields: %w", err)
        	}
        
        	// The response is not a list but an object "field name -> description", hence a map.
        	var addressFields map[string]struct {
        		Type       string `json:"type"`
        		Title      string `json:"title"`
        		IsReadOnly bool   `json:"isReadOnly"`
        	}
        	if err := json.Unmarshal(res.Result, &addressFields); err != nil {
        		return fmt.Errorf("parsing address fields: %w", err)
        	}
        
        	// The form takes only the string fields that are available for writing: TYPE_ID,
        	// ENTITY_ID, and ENTITY_TYPE_ID also arrive in this response, but the handler
        	// substitutes them itself. Map keys in Go are unordered — sort them, otherwise
        	// the form fields will jump around from run to run.
        	var addressNames []string
        	for name, f := range addressFields {
        		if f.Type == "string" && !f.IsReadOnly {
        			addressNames = append(addressNames, name)
        		}
        	}
        	sort.Strings(addressNames)
        	res, err = core.Call(ctx, "crm.requisite.preset.list", b24.Params{
        		"select": []string{"ID", "NAME"},
        	}, b24.WithIdempotent())
        	if err != nil {
        		return fmt.Errorf("crm.requisite.preset.list: %w", err)
        	}
        
        	// Here the identifier arrives as a STRING ("1"), whereas crm.enum.* returns
        	// numbers. b24.ID parses both notations.
        	var presets []struct {
        		ID   b24.ID `json:"ID"`
        		Name string `json:"NAME"`
        	}
        	if err := json.Unmarshal(res.Result, &presets); err != nil {
        		return fmt.Errorf("parsing requisite templates: %w", err)
        	}
        	if len(presets) == 0 {
        		return fmt.Errorf("there are no requisite templates in Bitrix24")
        	}
        	// --- the page with the form
        	var form strings.Builder
        	form.WriteString(`<!doctype html>
        <meta charset="utf-8">
        <title>Request</title>
        <form method="post" action="/form">
        <p><label>Requisite type*<br><select name="REQ_TYPE" required>`)
        	for _, p := range presets {
        		fmt.Fprintf(&form, `<option value="%d">%s</option>`, p.ID, html.EscapeString(p.Name))
        	}
        	form.WriteString(`</select></label></p>
        <p><label>Org name*<br><input name="TITLE" required></label></p>
        <p><label>INN<br><input name="INN"></label></p>
        <p><label>Phone<br><input name="PHONE" type="tel"></label></p>`)
        	// The address fields are created dynamically: their set is defined by Bitrix24,
        	// not by the code. Names such as ADDRESS[CITY] — the handler parses them back.
        	for _, name := range addressNames {
        		fmt.Fprintf(&form, "<p><label>%s<br><input name=\"ADDRESS[%s]\"></label></p>\n",
        			html.EscapeString(addressFields[name].Title), name)
        	}
        	form.WriteString(`<p><button type="submit">Submit</button></p>
        </form>`)
        	page := form.String()
        	mux := http.NewServeMux()
        	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        		w.Header().Set("Content-Type", "text/html; charset=utf-8")
        		fmt.Fprint(w, page)
        	})
        	mux.HandleFunc("/form", func(w http.ResponseWriter, r *http.Request) {
        		if r.Method != http.MethodPost {
        			reply(w, http.StatusMethodNotAllowed, "POST required", 0)
        			return
        		}
        		handleForm(w, r, core)
        	})
        
        	log.Println("form and handler: http://localhost:3000/")
        	return http.ListenAndServe(":3000", mux)
        }
        
        func handleForm(w http.ResponseWriter, r *http.Request, core *b24.Core) {
        	ctx := r.Context()
        	if err := r.ParseForm(); err != nil {
        		reply(w, http.StatusBadRequest, "Failed to parse the form", 0)
        		return
        	}
        	// The requisite type is converted to a number, the rest is cleared of HTML tags.
        	// The tags are CUT OUT rather than escaped: escaping is needed when rendering to
        	// the page, and because of it the CRM would receive "Weber &amp; Son" instead of
        	// "Weber & Son".
        	presetID, _ := strconv.Atoi(r.PostFormValue("REQ_TYPE"))
        	title := stripTags(r.PostFormValue("TITLE"))
        	inn := stripTags(r.PostFormValue("INN"))
        	phone := stripTags(r.PostFormValue("PHONE"))
        
        	if presetID == 0 || title == "" {
        		reply(w, http.StatusBadRequest, "Fill in the requisite type and the name", 0)
        		return
        	}
        	// The address fields arrived with names such as ADDRESS[CITY] — parse them back.
        	address := b24.Params{}
        	for key, values := range r.PostForm {
        		if inner, ok := addressKey(key); ok && len(values) > 0 && values[0] != "" {
        			address[inner] = stripTags(values[0])
        		}
        	}
        	// The handler substitutes the address type and the owner type itself: they are not in the form.
        	address["TYPE_ID"] = addressTypeActual
        	address["ENTITY_TYPE_ID"] = typeRequisite
        	// The phone number is retained as a multifield — a list of objects, even when
        	// there is a single number. A row WITHOUT an ID adds a value; MultifieldAdd
        	// assembles it for you.
        	phones := []map[string]any{}
        	if phone != "" {
        		phones = append(phones, b24.MultifieldAdd(phone, "WORK"))
        	}
        	res, err := core.Call(ctx, "crm.company.add", b24.Params{
        		"fields": b24.Params{
        			"TITLE":        title,
        			"COMPANY_TYPE": "CUSTOMER",
        			"PHONE":        phones,
        		},
        	}) // without WithIdempotent: a retry would create a second company
        	if err != nil {
        		// The details go to the server log, they are not shown to the visitor.
        		log.Println("crm.company.add:", err)
        		reply(w, http.StatusBadGateway, "Failed to create the company", 0)
        		return
        	}
        
        	// There is no wrapper: result is the identifier of the new company right away.
        	var companyID b24.ID
        	if err := json.Unmarshal(res.Result, &companyID); err != nil {
        		log.Println("parsing the company identifier:", err)
        		reply(w, http.StatusBadGateway, "Failed to create the company", 0)
        		return
        	}
        	res, err = core.Call(ctx, "crm.requisite.add", b24.Params{
        		"fields": b24.Params{
        			"ENTITY_TYPE_ID": typeCompany,
        			"ENTITY_ID":      companyID,
        			"PRESET_ID":      presetID,
        			"ACTIVE":         "Y",
        			"NAME":           title,
        			"RQ_INN":         inn,
        		},
        	})
        	if err != nil {
        		// The company has already been created, so this is no reason to answer
        		// "nothing worked": report that the requisites were not added and return the
        		// identifier.
        		log.Println("crm.requisite.add:", err)
        		reply(w, http.StatusOK, "The company was created, the requisites could not be added", companyID)
        		return
        	}
        	var requisiteID b24.ID
        	if err := json.Unmarshal(res.Result, &requisiteID); err != nil {
        		log.Println("parsing the requisite identifier:", err)
        		reply(w, http.StatusOK, "The company was created, the requisites could not be added", companyID)
        		return
        	}
        	// The address is linked to the REQUISITE, not to the company, so ENTITY_ID
        	// is filled in only now — the requisite identifier did not exist earlier.
        	if requisiteID != 0 {
        		address["ENTITY_ID"] = requisiteID
        		if _, err := core.Call(ctx, "crm.address.add", b24.Params{"fields": address}); err != nil {
        			log.Println("crm.address.add:", err)
        			reply(w, http.StatusOK, "The company and the requisites were created, the address could not be added", companyID)
        			return
        		}
        	}
        	log.Printf("created company %d, requisite %d", companyID, requisiteID)
        	reply(w, http.StatusOK, "The company with requisites has been created", companyID)
        }
        
        // tagPattern cuts HTML tags out of a form value.
        var tagPattern = regexp.MustCompile(`<[^>]*>`)
        
        func stripTags(s string) string {
        	return strings.TrimSpace(tagPattern.ReplaceAllString(s, ""))
        }
        
        // addressKey extracts CITY from the ADDRESS[CITY] field name.
        func addressKey(key string) (string, bool) {
        	if strings.HasPrefix(key, "ADDRESS[") && strings.HasSuffix(key, "]") {
        		return key[len("ADDRESS[") : len(key)-1], true
        	}
        	return "", false
        }
        
        // reply answers the page with the same JSON as the handlers in the other languages.
        func reply(w http.ResponseWriter, status int, message string, id b24.ID) {
        	w.Header().Set("Content-Type", "application/json; charset=utf-8")
        	w.WriteHeader(status)
        	body := map[string]any{"message": message}
        	if id != 0 {
        		body["id"] = id
        	}
        	_ = json.NewEncoder(w).Encode(body)
        }
        

requisites = client.crm.requisite.list(
            filter={"ENTITY_TYPE_ID": 4, "ENTITY_ID": i_company_id},
            select=["ID", "ENTITY_TYPE_ID", "ENTITY_ID", "NAME"],
        ).result
        
        addresses = client.crm.address.list(
            filter={"ENTITY_TYPE_ID": 8, "ENTITY_ID": i_requisite_id},
        ).result
        
        print(requisites)
        print(addresses)
        

$requisites = $sb->getCRMScope()->requisite()->list(
            [],
            ['ENTITY_TYPE_ID' => 4, 'ENTITY_ID' => $iCompanyID],
            ['ID', 'ENTITY_TYPE_ID', 'ENTITY_ID', 'NAME']
        )->getRequisites();
        
        $addresses = $sb->getCRMScope()->address()->list(
            [],
            ['ENTITY_TYPE_ID' => 8, 'ENTITY_ID' => $iRequisiteID],
            []
        )->getAddresses();
        
        print_r($requisites);
        print_r($addresses);
        

res, err := core.Call(ctx, "crm.requisite.list", b24.Params{
        	"filter": b24.Params{"ENTITY_TYPE_ID": 4, "ENTITY_ID": companyID},
        	"select": []string{"ID", "ENTITY_TYPE_ID", "ENTITY_ID", "NAME"},
        }, b24.WithIdempotent())
        if err != nil {
        	return fmt.Errorf("crm.requisite.list: %w", err)
        }
        log.Println("company requisites:", string(res.Result))
        
        res, err = core.Call(ctx, "crm.address.list", b24.Params{
        	"filter": b24.Params{"ENTITY_TYPE_ID": 8, "ENTITY_ID": requisiteID},
        }, b24.WithIdempotent())
        if err != nil {
        	return fmt.Errorf("crm.address.list: %w", err)
        }
        log.Println("requisite addresses:", string(res.Result))