How to Configure Rounding for a Number Custom Field

// 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('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        

from b24pysdk import BitrixWebhook, Client
        from b24pysdk.errors import BitrixAPIError
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        

// The webhook path is a secret, so it comes from the environment, not from the code.
        // The client is built once per portal: it holds the HTTP client and the
        // authorization state.
        core := b24.NewClient(os.Getenv("B24_WEBHOOK_URL")).Core()
        

// userfieldconfig.add has no typed wrapper in the SDK — calling the method via the core
        $createdField = $sb->core->call(
            'userfieldconfig.add',
            [
                'moduleId' => 'crm', // Module identifier
                'field' => [
                    'entityId' => 'CRM_DEAL', // Object identifier
                    'fieldName' => 'UF_CRM_DEAL_NEW_DOUBLE_FIELD', // Field code
                    'userTypeId' => 'double', // Field type identifier
                    'editFormLabel' => [
                        'de' => 'Number with rounding', // Field name in Russian
                        'en' => 'PRECISION double' // Field name in English
                    ],
                    'settings' => [ // Additional field settings
                        'PRECISION' => 3 // Number of decimal places
                    ]
                ]
            ]
        )->getResponseData()->getResult()['field'];
        
        echo $createdField['id'] . ': ' . $createdField['settings']['PRECISION'];
        

try:
            created_field = client.userfieldconfig.add(
                module_id="crm",
                field={
                    "entityId": "CRM_DEAL",
                    "fieldName": "UF_CRM_DEAL_NEW_DOUBLE_FIELD",
                    "userTypeId": "double",
                    "editFormLabel": {
                        "de": "Number with rounding",
                        "en": "PRECISION double",
                    },
                    "settings": {
                        "PRECISION": 3,
                    },
                },
            ).response.result["field"]
        except BitrixAPIError as error:
            print(f"Error: {error}")
        else:
            print(created_field["id"], created_field["settings"]["PRECISION"])
        

res, err := core.Call(ctx, "userfieldconfig.add", b24.Params{
        	"moduleId": "crm",
        	"field": b24.Params{
        		"entityId":   "CRM_DEAL",
        		"fieldName":  fieldName,
        		"userTypeId": "double",
        		"editFormLabel": b24.Params{
        			"ru": fieldLabel,
        			"en": "PRECISION double",
        		},
        		// The parameter is optional, but for the "Number" type it is better to
        		// pass it: without it the precision will be 0 and the values will be rounded
        		// to whole numbers.
        		"settings": b24.Params{"PRECISION": 3},
        	},
        })
        if err != nil {
        	// The error code is compared with errors.Is rather than as a string: a typo in the
        	// literal would compile and silently take a different branch.
        	if errors.Is(err, b24.ErrAccessDenied) {
        		return fmt.Errorf("the \"Allow to change settings\" permission is required in CRM: %w", err)
        	}
        	return fmt.Errorf("userfieldconfig.add: %w", err)
        }
        
        // The method wraps the response in an object with the field key and responds in camelCase:
        // the precision is in settings.PRECISION rather than in SETTINGS.PRECISION.
        var added struct {
        	Field struct {
        		ID       b24.ID         `json:"id"`
        		Settings map[string]any `json:"settings"`
        	} `json:"field"`
        }
        if err := json.Unmarshal(res.Result, &added); err != nil {
        	return fmt.Errorf("parse the created field: %w", err)
        }
        

$fields = $sb->getCRMScope()->dealUserfield()->list(
            order: [],
            filter: [
                'LANG' => 'de', // Language filter for field name output
                'USER_TYPE_ID' => 'double' // Field type filter
            ]
        )->getUserfields();
        
        // Select the required field by name — replace with your field name
        $targetField = null;
        foreach ($fields as $field) {
            if ($field->EDIT_FORM_LABEL === 'Amount to return') {
                $targetField = $field;
                break;
            }
        }
        
        if ($targetField === null) {
            throw new \RuntimeException('Field with the specified name not found');
        }
        

fields = client.crm.deal.userfield.list(
            filter={
                "LANG": "de",
                "USER_TYPE_ID": "double",
            }
        ).response.result
        
        # Select the required field by name — replace with your field name
        target_field = next(
            (field for field in fields if field["EDIT_FORM_LABEL"] == "Amount to return"),
            None,
        )
        
        if target_field is None:
            raise RuntimeError("Field with the specified name not found")
        

// Without the LANG filter the titles are not returned at all, and finding a field by its title
        // will not work.
        res, err = core.Call(ctx, "crm.deal.userfield.list", b24.Params{
        	"filter": b24.Params{"LANG": "ru", "USER_TYPE_ID": "double"},
        }, b24.WithIdempotent())
        if err != nil {
        	return fmt.Errorf("crm.deal.userfield.list: %w", err)
        }
        
        // And this method responds in UPPER_SNAKE — the same data, a different case.
        // The keys inside the settings themselves are uppercase in both cases.
        var fields []struct {
        	ID            b24.ID         `json:"ID"`
        	FieldName     string         `json:"FIELD_NAME"`
        	EditFormLabel string         `json:"EDIT_FORM_LABEL"`
        	Settings      map[string]any `json:"SETTINGS"`
        }
        if err := json.Unmarshal(res.Result, &fields); err != nil {
        	return fmt.Errorf("parse custom fields: %w", err)
        }
        
        target := -1
        for i, f := range fields {
        	if f.EditFormLabel == fieldLabel {
        		target = i
        		break
        	}
        }
        if target < 0 {
        	return fmt.Errorf("field %q not found", fieldLabel)
        }
        

// userfieldconfig.update has no typed wrapper in the SDK — calling the method via the core
        $updatedField = $sb->core->call(
            'userfieldconfig.update',
            [
                'moduleId' => 'crm', // Module identifier
                'id' => (int)$targetField->ID, // Field ID from step 1
                'field' => [
                    'settings' => array_merge(
                        (array)$targetField->SETTINGS, // Transfer current settings from step 1
                        ['PRECISION' => 3] // Number of decimal places
                    )
                ]
            ]
        )->getResponseData()->getResult()['field'];
        
        echo $updatedField['id'] . ': ' . $updatedField['settings']['PRECISION'];
        

updated_field = client.userfieldconfig.update(
            module_id="crm",
            bitrix_id=int(target_field["ID"]),
            field={
                "settings": {
                    **target_field["SETTINGS"],  # Transfer current settings from step 1
                    "PRECISION": 3,
                }
            },
        ).response.result["field"]
        
        print(updated_field["id"], updated_field["settings"]["PRECISION"])
        

// settings are REPLACED as a whole rather than appended to. If you pass one
        // PRECISION, the remaining settings of the "Number" type will reset to their default
        // values — that is why the settings from step 1 are taken and one of them is changed.
        settings := fields[target].Settings
        settings["PRECISION"] = 5
        
        res, err = core.Call(ctx, "userfieldconfig.update", b24.Params{
        	"moduleId": "crm",
        	"id":       fields[target].ID,
        	"field":    b24.Params{"settings": settings},
        })
        if err != nil {
        	return fmt.Errorf("userfieldconfig.update: %w", err)
        }
        
        var updated struct {
        	Field struct {
        		ID       b24.ID         `json:"id"`
        		Settings map[string]any `json:"settings"`
        	} `json:"field"`
        }
        if err := json.Unmarshal(res.Result, &updated); err != nil {
        	return fmt.Errorf("parse the updated field: %w", err)
        }
        

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Bitrix24\SDK\Services\ServiceBuilder;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        use Psr\Log\NullLogger;
        
        $sb = (new ServiceBuilderFactory(new EventDispatcher(), new NullLogger()))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        const FIELD_LABEL = 'Amount to return'; // Field name to be changed
        const PRECISION = 3; // Number of decimal places
        
        function updateUserField(ServiceBuilder $sb, string $fieldLabel, int $precision): void {
            try {
                // Step 1: get deal user fields of type double
                $fields = $sb->getCRMScope()->dealUserfield()->list(
                    order: [],
                    filter: [
                        'LANG' => 'de', // Language filter for field name output
                        'USER_TYPE_ID' => 'double' // Field type filter
                    ]
                )->getUserfields();
        
                // The crm.deal.userfield.list response comes in UPPER_SNAKE
                $targetField = null;
                foreach ($fields as $field) {
                    if ($field->EDIT_FORM_LABEL === $fieldLabel) {
                        $targetField = $field;
                        break;
                    }
                }
        
                if ($targetField === null) {
                    throw new \RuntimeException('Field with the specified name not found');
                }
        
                // Step 2: update settings of the found field
                // userfieldconfig.update has no typed wrapper in the SDK — calling the method via the core
                $updatedField = $sb->core->call(
                    'userfieldconfig.update',
                    [
                        'moduleId' => 'crm', // Module identifier
                        'id' => (int)$targetField->ID, // ID of the found user field
                        'field' => [
                            'settings' => array_merge(
                                (array)$targetField->SETTINGS, // Transfer current field settings
                                ['PRECISION' => $precision] // Number of decimal places
                            )
                        ]
                    ]
                )->getResponseData()->getResult()['field'];
        
                // The userfieldconfig.update response comes in camelCase
                echo 'Field precision: ' . $updatedField['settings']['PRECISION'];
            } catch (\Throwable $e) {
                echo 'Error: ' . $e->getMessage();
            }
        }
        
        updateUserField($sb, FIELD_LABEL, PRECISION);
        

from b24pysdk import BitrixWebhook, Client
        from b24pysdk.errors import BitrixAPIError
        
        FIELD_LABEL = "Amount to return"  # Field name to be changed
        PRECISION = 3  # Number of decimal places
        
        def update_user_field(client, field_label: str, precision: int) -> None:
            try:
                # Step 1: get deal user fields of type double
                fields = client.crm.deal.userfield.list(
                    filter={
                        "LANG": "de",
                        "USER_TYPE_ID": "double",
                    }
                ).response.result
        
                # The crm.deal.userfield.list response comes in UPPER_SNAKE
                target_field = next(
                    (field for field in fields if field["EDIT_FORM_LABEL"] == field_label),
                    None,
                )
        
                if target_field is None:
                    raise RuntimeError("Field with the specified name not found")
        
                # Step 2: update settings of the found field
                updated_field = client.userfieldconfig.update(
                    module_id="crm",
                    bitrix_id=int(target_field["ID"]),
                    field={
                        "settings": {
                            **target_field["SETTINGS"],  # Transfer current field settings
                            "PRECISION": precision,
                        }
                    },
                ).response.result["field"]
            except (BitrixAPIError, RuntimeError) as error:
                print(f"Error: {error}")
            else:
                # The userfieldconfig.update response comes in camelCase
                print("Field precision:", updated_field["settings"]["PRECISION"])
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        
        update_user_field(client, FIELD_LABEL, PRECISION)
        

// 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 is self-contained: it creates a deal field with a precision of 2, finds it
        // by title, changes the precision to 3, and deletes the field afterwards. The second scenario
        // of the page requires an already existing field — the example prepares it in the first
        // scenario, so it runs on any portal and nothing needs to be edited.
        package main
        
        import (
        	"context"
        	"encoding/json"
        	"errors"
        	"fmt"
        	"log"
        	"os"
        
        	b24 "github.com/bitrix24/b24gosdk"
        )
        
        const (
        	fieldName  = "UF_CRM_DEAL_NEW_DOUBLE_FIELD"
        	fieldLabel = "Rounded number"
        )
        
        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.
        	// The client is built once per portal: it holds the HTTP client and the
        	// authorization state.
        	core := b24.NewClient(os.Getenv("B24_WEBHOOK_URL")).Core()
        	// --- scenario 1: create the field with the precision right away
        	res, err := core.Call(ctx, "userfieldconfig.add", b24.Params{
        		"moduleId": "crm",
        		"field": b24.Params{
        			"entityId":   "CRM_DEAL",
        			"fieldName":  fieldName,
        			"userTypeId": "double",
        			"editFormLabel": b24.Params{
        				"ru": fieldLabel,
        				"en": "PRECISION double",
        			},
        			// The parameter is optional, but for the "Number" type it is better to
        			// pass it: without it the precision will be 0 and the values will be rounded
        			// to whole numbers.
        			"settings": b24.Params{"PRECISION": 3},
        		},
        	})
        	if err != nil {
        		// The error code is compared with errors.Is rather than as a string: a typo in the
        		// literal would compile and silently take a different branch.
        		if errors.Is(err, b24.ErrAccessDenied) {
        			return fmt.Errorf("the \"Allow to change settings\" permission is required in CRM: %w", err)
        		}
        		return fmt.Errorf("userfieldconfig.add: %w", err)
        	}
        
        	// The method wraps the response in an object with the field key and responds in camelCase:
        	// the precision is in settings.PRECISION rather than in SETTINGS.PRECISION.
        	var added struct {
        		Field struct {
        			ID       b24.ID         `json:"id"`
        			Settings map[string]any `json:"settings"`
        		} `json:"field"`
        	}
        	if err := json.Unmarshal(res.Result, &added); err != nil {
        		return fmt.Errorf("parse the created field: %w", err)
        	}
        	defer del(ctx, core, "userfieldconfig.delete", b24.Params{
        		"moduleId": "crm", "id": added.Field.ID,
        	})
        	fmt.Printf("field %d created, PRECISION=%v\n", added.Field.ID, added.Field.Settings["PRECISION"])
        
        	// --- scenario 2, step 1: find the field by its title
        	// Without the LANG filter the titles are not returned at all, and finding a field by its title
        	// will not work.
        	res, err = core.Call(ctx, "crm.deal.userfield.list", b24.Params{
        		"filter": b24.Params{"LANG": "ru", "USER_TYPE_ID": "double"},
        	}, b24.WithIdempotent())
        	if err != nil {
        		return fmt.Errorf("crm.deal.userfield.list: %w", err)
        	}
        
        	// And this method responds in UPPER_SNAKE — the same data, a different case.
        	// The keys inside the settings themselves are uppercase in both cases.
        	var fields []struct {
        		ID            b24.ID         `json:"ID"`
        		FieldName     string         `json:"FIELD_NAME"`
        		EditFormLabel string         `json:"EDIT_FORM_LABEL"`
        		Settings      map[string]any `json:"SETTINGS"`
        	}
        	if err := json.Unmarshal(res.Result, &fields); err != nil {
        		return fmt.Errorf("parse custom fields: %w", err)
        	}
        
        	target := -1
        	for i, f := range fields {
        		if f.EditFormLabel == fieldLabel {
        			target = i
        			break
        		}
        	}
        	if target < 0 {
        		return fmt.Errorf("field %q not found", fieldLabel)
        	}
        	fmt.Printf("found field %d (%s), currently PRECISION=%v\n",
        		fields[target].ID, fields[target].FieldName, fields[target].Settings["PRECISION"])
        
        	// --- scenario 2, step 2: change the precision
        	// settings are REPLACED as a whole rather than appended to. If you pass one
        	// PRECISION, the remaining settings of the "Number" type will reset to their default
        	// values — that is why the settings from step 1 are taken and one of them is changed.
        	settings := fields[target].Settings
        	settings["PRECISION"] = 5
        
        	res, err = core.Call(ctx, "userfieldconfig.update", b24.Params{
        		"moduleId": "crm",
        		"id":       fields[target].ID,
        		"field":    b24.Params{"settings": settings},
        	})
        	if err != nil {
        		return fmt.Errorf("userfieldconfig.update: %w", err)
        	}
        
        	var updated struct {
        		Field struct {
        			ID       b24.ID         `json:"id"`
        			Settings map[string]any `json:"settings"`
        		} `json:"field"`
        	}
        	if err := json.Unmarshal(res.Result, &updated); err != nil {
        		return fmt.Errorf("parse the updated field: %w", err)
        	}
        	fmt.Printf("field %d: PRECISION=%v, the remaining settings are retained: %v\n",
        		updated.Field.ID, updated.Field.Settings["PRECISION"], updated.Field.Settings)
        	return nil
        }
        
        // 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