diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/RegistriesFilterConfig.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/RegistriesFilterConfig.java
new file mode 100644
index 000000000..d2989961c
--- /dev/null
+++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/RegistriesFilterConfig.java
@@ -0,0 +1,39 @@
+package ru.spcex.clearing.backendapi.config;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.enumeration.RegistryStatus;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
+import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
+
+@Configuration
+public class RegistriesFilterConfig {
+
+    @Bean
+    public Map<String, ImdgPredicate> filterByName(ImdgProvider imdgProvider) {
+        ImdgPredicateBuilder predicateBuilder = imdgProvider
+            .getImdg(IMDGDistributedNames.Map_Registry, ExecutionDeposit.class)
+            .predicateBuilder();
+        return new HashMap<String, ImdgPredicate>() {{
+            put("fulfilledLiabilities", predicateBuilder.and(
+                predicateBuilder.regex("registryCode", "^[OT].*"),
+                predicateBuilder.in("registryStatus", Arrays.asList(RegistryStatus.OK.getKey(), RegistryStatus.CLRD.getKey()).toArray(new String[0])),
+                predicateBuilder.equals("settlementDate", LocalDate.now())));
+            put("unfulfilledLiabilities", predicateBuilder.and(
+                predicateBuilder.regex("registryCode", "^[OT].*"),
+                predicateBuilder.in("registryStatus", Arrays.asList(
+                    RegistryStatus.FAIL.getKey(),
+                    RegistryStatus.UNCV.getKey(),
+                    RegistryStatus.NACK.getKey(),
+                    RegistryStatus.NACC.getKey()).toArray(new String[0])),
+                predicateBuilder.equals("settlementDate", LocalDate.now())));
+        }};
+    }
+}
diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/RegistryController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/RegistryController.java
index 1a4061396..6198a533a 100644
--- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/RegistryController.java
+++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/RegistryController.java
@@ -19,6 +19,7 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Controller;
 import org.springframework.util.StopWatch;
+import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -54,14 +55,18 @@ public class RegistryController extends AbstractQueueController {
     protected final Logger log = LoggerFactory.getLogger(getClass());
     private final IStateLoader stateLoader;
     private final ImdgPredicateBuilder predicateBuilder;
+    private final Map<String, ImdgPredicate> filterByName;
 
     @Autowired
-    public RegistryController(IOperator operator, IStateLoader stateLoader, ImdgProvider imdgProvider) {
+    public RegistryController(IOperator operator, IStateLoader stateLoader,
+                              ImdgProvider imdgProvider,
+                              Map<String, ImdgPredicate> filterByName) {
         super(operator);
         this.stateLoader = stateLoader;
         this.predicateBuilder = imdgProvider
             .getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class)
             .predicateBuilder();
+        this.filterByName = filterByName;
     }
 
     @ApiOperation(value = "get all registries.")
@@ -95,39 +100,25 @@ public class RegistryController extends AbstractQueueController {
     @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
     @RequestMapping(value = "/filter", method = RequestMethod.GET)
     @ResponseBody
-    public CommonGetAllResponse getByFilter(@RequestParam(name = "registryCode", required = false) Optional<String> registryCode,
-                                            @RequestParam(name = "status", required = false) Optional<List<String>> status,
+    public CommonGetAllResponse getByFilter(@RequestParam(name = "kind", required = false) String kind,
                                             @RequestParam(name = "pageSize", required = false) Optional<Integer> pageSize,
                                             @RequestParam(name = "pageIndex", required = false) Optional<Integer> pageIndex) {
-        if (registryCode.isEmpty() && status.isEmpty()) {
+        if (!StringUtils.hasText(kind)) {
             throw new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, "Request should have at least one of the parameters: designation, status");
         }
+        if (!filterByName.containsKey(kind)) {
+            throw new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, "Kind is not supported: " + kind);
+        }
 
         StopWatch sw = new StopWatch("registry-controller-stopwatch");
         sw.start();
 
-        List<ImdgPredicate> filters = new ArrayList<>();
-        registryCode.ifPresent(regex -> filters.add(predicateBuilder.regex("registryCode", regex)));
-
-        status.ifPresent(collection -> {
-            String[] values = collection.stream()
-                .map(val -> Optional.ofNullable(IEnumKey.getEnumByKey(RegistryStatus.class, val))
-                    .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, "Unknown registry status: " + val)))
-                .map(RegistryStatus::getKey)
-                .toArray(String[]::new);
-            filters.add(predicateBuilder.in("registryStatus", values));
-        });
-
+        ImdgPredicate filter = predicateBuilder.and(filterByName.get(kind));
         AtomicReference<Collection<Map<String, Object>>> all = new AtomicReference<>();
-        pageIndex.ifPresentOrElse(index -> {
-                ImdgPredicate filter = predicateBuilder.and(filters.toArray(ImdgPredicate[]::new));
+        pageIndex.ifPresentOrElse(index ->
                 all.set(stateLoader.getAllMetaTransformWithPagination(IMDGDistributedNames.Map_Registry, Registry.class, filter,
-                    pageSize.orElse(10_000), index));
-            },
-            () -> {
-                ImdgPredicate filter = predicateBuilder.and(filters.toArray(ImdgPredicate[]::new));
-                all.set(stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Registry, Registry.class, filter));
-            });
+                    pageSize.orElse(10_000), index)),
+            () -> all.set(stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Registry, Registry.class, filter)));
 
         sw.stop();
         log.info("Info select and format {} data took {} ms", all.get().size(), sw.getLastTaskTimeMillis());