diff --git a/java/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshot.java b/java/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshot.java
index 4595fff..783019b 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshot.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshot.java
@@ -118,16 +118,40 @@
   /**
    * Checks whether newly added non-resolvable code owners should be rejected on commit received and
    * submit.
+   *
+   * @param branchName the branch for which it should be checked whether non-resolvable code owners
+   *     should be rejected
    */
-  public boolean rejectNonResolvableCodeOwners() {
+  public boolean rejectNonResolvableCodeOwners(String branchName) {
+    requireNonNull(branchName, "branchName");
+
+    Optional<Boolean> branchSpecificFlag =
+        generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+            BranchNameKey.create(projectName, branchName), pluginConfig);
+    if (branchSpecificFlag.isPresent()) {
+      return branchSpecificFlag.get();
+    }
+
     return generalConfig.getRejectNonResolvableCodeOwners(projectName, pluginConfig);
   }
 
   /**
    * Checks whether newly added non-resolvable imports should be rejected on commit received and
    * submit.
+   *
+   * @param branchName the branch for which it should be checked whether non-resolvable imports
+   *     should be rejected
    */
-  public boolean rejectNonResolvableImports() {
+  public boolean rejectNonResolvableImports(String branchName) {
+    requireNonNull(branchName, "branchName");
+
+    Optional<Boolean> branchSpecificFlag =
+        generalConfig.getRejectNonResolvableImportsForBranch(
+            BranchNameKey.create(projectName, branchName), pluginConfig);
+    if (branchSpecificFlag.isPresent()) {
+      return branchSpecificFlag.get();
+    }
+
     return generalConfig.getRejectNonResolvableImports(projectName, pluginConfig);
   }
 
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfig.java b/java/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfig.java
index caf8de0..eb84049 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfig.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfig.java
@@ -234,15 +234,15 @@
   }
 
   /**
-   * Gets the reject-non-resolvable-code-owners configuration from the given plugin config with
-   * fallback to {@code gerrit.config}.
+   * Gets the reject-non-resolvable-code-owners configuration from the given plugin config for the
+   * specified project with fallback to {@code gerrit.config}.
    *
    * <p>The reject-non-resolvable-code-owners configuration controls whether code owner config files
    * with newly added non-resolvable code owners should be rejected on commit received and on
    * submit.
    *
-   * @param project the project for which the freject-non-resolvable-code-owners configuration
-   *     should be read
+   * @param project the project for which the reject-non-resolvable-code-owners configuration should
+   *     be read
    * @param pluginConfig the plugin config from which the reject-non-resolvable-code-owners
    *     configuration should be read.
    * @return whether code owner config files with newly added non-resolvable code owners should be
@@ -254,13 +254,37 @@
   }
 
   /**
-   * Gets the reject-non-resolvable-imports configuration from the given plugin config with fallback
-   * to {@code gerrit.config}.
+   * Gets the reject-non-resolvable-code-owners configuration from the given plugin config for the
+   * specified branch with fallback to {@code gerrit.config}.
+   *
+   * <p>If multiple branch-specific configurations match the specified branch, it is undefined which
+   * of the matching branch configurations takes precedence.
+   *
+   * <p>The reject-non-resolvable-code-owners configuration controls whether code owner config files
+   * with newly added non-resolvable code owners should be rejected on commit received and on
+   * submit.
+   *
+   * @param branchNameKey the branch and project for which the reject-non-resolvable-code-owners
+   *     configuration should be read
+   * @param pluginConfig the plugin config from which the reject-non-resolvable-code-owners
+   *     configuration should be read.
+   * @return whether code owner config files with newly added non-resolvable code owners should be
+   *     rejected on commit received and on submit
+   */
+  Optional<Boolean> getRejectNonResolvableCodeOwnersForBranch(
+      BranchNameKey branchNameKey, Config pluginConfig) {
+    return getCodeOwnerConfigValidationFlagForBranch(
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS, branchNameKey, pluginConfig);
+  }
+
+  /**
+   * Gets the reject-non-resolvable-imports configuration from the given plugin config for the
+   * specified project with fallback to {@code gerrit.config}.
    *
    * <p>The reject-non-resolvable-imports configuration controls whether code owner config files
    * with newly added non-resolvable imports should be rejected on commit received and on submit.
    *
-   * @param project the project for which the freject-non-resolvable-imports configuration should be
+   * @param project the project for which the reject-non-resolvable-imports configuration should be
    *     read
    * @param pluginConfig the plugin config from which the reject-non-resolvable-imports
    *     configuration should be read.
@@ -272,6 +296,26 @@
         project, pluginConfig, KEY_REJECT_NON_RESOLVABLE_IMPORTS, /* defaultValue= */ true);
   }
 
+  /**
+   * Gets the reject-non-resolvable-imports configuration from the given plugin config for the
+   * specified branch with fallback to {@code gerrit.config}.
+   *
+   * <p>The reject-non-resolvable-imports configuration controls whether code owner config files
+   * with newly added non-resolvable imports should be rejected on commit received and on submit.
+   *
+   * @param branchNameKey the branch and project for which the reject-non-resolvable-imports
+   *     configuration should be read
+   * @param pluginConfig the plugin config from which the reject-non-resolvable-imports
+   *     configuration should be read.
+   * @return whether code owner config files with newly added non-resolvable imports should be
+   *     rejected on commit received and on submit
+   */
+  Optional<Boolean> getRejectNonResolvableImportsForBranch(
+      BranchNameKey branchNameKey, Config pluginConfig) {
+    return getCodeOwnerConfigValidationFlagForBranch(
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS, branchNameKey, pluginConfig);
+  }
+
   private boolean getBooleanConfig(
       Project.NameKey project, Config pluginConfig, String key, boolean defaultValue) {
     requireNonNull(project, "project");
@@ -493,6 +537,22 @@
         validationSectionForBranch.get(), key, branchNameKey.project(), pluginConfig);
   }
 
+  private Optional<Boolean> getCodeOwnerConfigValidationFlagForBranch(
+      String key, BranchNameKey branchNameKey, Config pluginConfig) {
+    requireNonNull(key, "key");
+    requireNonNull(branchNameKey, "branchNameKey");
+    requireNonNull(pluginConfig, "pluginConfig");
+
+    Optional<String> validationSectionForBranch =
+        getValidationSectionForBranch(branchNameKey, pluginConfig);
+    if (!validationSectionForBranch.isPresent()) {
+      return Optional.empty();
+    }
+
+    return getCodeOwnerConfigValidationFlagForBranch(
+        validationSectionForBranch.get(), key, branchNameKey.project(), pluginConfig);
+  }
+
   private CodeOwnerConfigValidationPolicy getCodeOwnerConfigValidationPolicy(
       String key, Project.NameKey project, Config pluginConfig) {
     requireNonNull(key, "key");
@@ -601,6 +661,34 @@
     return Optional.empty();
   }
 
+  private Optional<Boolean> getCodeOwnerConfigValidationFlagForBranch(
+      String branchSubsection, String key, Project.NameKey project, Config pluginConfig) {
+    requireNonNull(branchSubsection, "branchSubsection");
+    requireNonNull(key, "key");
+    requireNonNull(project, "project");
+    requireNonNull(pluginConfig, "pluginConfig");
+
+    String codeOwnerConfigValidationFlagString =
+        pluginConfig.getString(SECTION_VALIDATION, branchSubsection, key);
+    if (codeOwnerConfigValidationFlagString != null) {
+      try {
+        return Optional.of(
+            pluginConfig.getBoolean(SECTION_VALIDATION, branchSubsection, key, true));
+      } catch (IllegalArgumentException e) {
+        logger.atWarning().withCause(e).log(
+            "Ignoring invalid value %s for %s.%s.%s in '%s.config' of project %s."
+                + " Falling back to project-level setting.",
+            codeOwnerConfigValidationFlagString,
+            SECTION_VALIDATION,
+            branchSubsection,
+            key,
+            pluginName,
+            project.get());
+      }
+    }
+    return Optional.empty();
+  }
+
   /**
    * Gets the merge commit strategy from the given plugin config with fallback to {@code
    * gerrit.config}.
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/CheckCodeOwnerConfigFiles.java b/java/com/google/gerrit/plugins/codeowners/restapi/CheckCodeOwnerConfigFiles.java
index 306442a..1eaaed6 100644
--- a/java/com/google/gerrit/plugins/codeowners/restapi/CheckCodeOwnerConfigFiles.java
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/CheckCodeOwnerConfigFiles.java
@@ -177,11 +177,7 @@
               problemsByPath.putAll(
                   codeOwnerBackend.getFilePath(codeOwnerConfig.key()).toString(),
                   checkCodeOwnerConfig(
-                      branchNameKey.project(),
-                      revWalk,
-                      codeOwnerBackend,
-                      codeOwnerConfig,
-                      verbosity));
+                      branchNameKey, revWalk, codeOwnerBackend, codeOwnerConfig, verbosity));
               return true;
             },
             (codeOwnerConfigFilePath, configInvalidException) -> {
@@ -196,14 +192,14 @@
   }
 
   private ImmutableList<ConsistencyProblemInfo> checkCodeOwnerConfig(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       RevWalk revWalk,
       CodeOwnerBackend codeOwnerBackend,
       CodeOwnerConfig codeOwnerConfig,
       @Nullable ConsistencyProblemInfo.Status verbosity) {
     return codeOwnerConfigValidator
         .validateCodeOwnerConfig(
-            project,
+            branchNameKey,
             revWalk,
             currentUser.get().asIdentifiedUser(),
             codeOwnerBackend,
diff --git a/java/com/google/gerrit/plugins/codeowners/validation/CodeOwnerConfigValidator.java b/java/com/google/gerrit/plugins/codeowners/validation/CodeOwnerConfigValidator.java
index 4f03274..ce10743 100644
--- a/java/com/google/gerrit/plugins/codeowners/validation/CodeOwnerConfigValidator.java
+++ b/java/com/google/gerrit/plugins/codeowners/validation/CodeOwnerConfigValidator.java
@@ -494,7 +494,7 @@
         // issues. Hence in this case we downgrade all validation errors in the new version to
         // warnings so that the update is not blocked.
         return validateCodeOwnerConfig(
-                branchNameKey.project(), revWalk, user, codeOwnerBackend, codeOwnerConfig)
+                branchNameKey, revWalk, user, codeOwnerBackend, codeOwnerConfig)
             .map(CodeOwnerConfigValidator::downgradeErrorToWarning);
       }
 
@@ -505,15 +505,14 @@
     // Validate the parsed code owner config.
     if (baseCodeOwnerConfig.isPresent()) {
       return validateCodeOwnerConfig(
-          branchNameKey.project(),
+          branchNameKey,
           revWalk,
           user,
           codeOwnerBackend,
           codeOwnerConfig,
           baseCodeOwnerConfig.get());
     }
-    return validateCodeOwnerConfig(
-        branchNameKey.project(), revWalk, user, codeOwnerBackend, codeOwnerConfig);
+    return validateCodeOwnerConfig(branchNameKey, revWalk, user, codeOwnerBackend, codeOwnerConfig);
   }
 
   /**
@@ -679,7 +678,7 @@
    * <p>Validation errors that exist in both code owner configs are returned as warning (because
    * they are not newly introduced by the given code owner config).
    *
-   * @param project the name of the project
+   * @param branchNameKey the branch and the project
    * @param revWalk rev walk that should be used to load the code owner configs
    * @param user user for which the code owner visibility checks should be performed
    * @param codeOwnerBackend the code owner backend from which the code owner configs were loaded
@@ -689,7 +688,7 @@
    *     empty stream if there are no issues
    */
   private Stream<CommitValidationMessage> validateCodeOwnerConfig(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       RevWalk revWalk,
       IdentifiedUser user,
       CodeOwnerBackend codeOwnerBackend,
@@ -699,9 +698,9 @@
     requireNonNull(baseCodeOwnerConfig, "baseCodeOwnerConfig");
 
     ImmutableSet<CommitValidationMessage> issuesInBaseVersion =
-        validateCodeOwnerConfig(project, revWalk, user, codeOwnerBackend, baseCodeOwnerConfig)
+        validateCodeOwnerConfig(branchNameKey, revWalk, user, codeOwnerBackend, baseCodeOwnerConfig)
             .collect(toImmutableSet());
-    return validateCodeOwnerConfig(project, revWalk, user, codeOwnerBackend, codeOwnerConfig)
+    return validateCodeOwnerConfig(branchNameKey, revWalk, user, codeOwnerBackend, codeOwnerConfig)
         .map(
             commitValidationMessage ->
                 issuesInBaseVersion.contains(commitValidationMessage)
@@ -712,7 +711,7 @@
   /**
    * Validates the given code owner config and returns validation issues as stream.
    *
-   * @param project the name of the project
+   * @param branchNameKey the branch and the project
    * @param revWalk rev walk that should be used to load the code owner configs from {@code project}
    * @param user user for which the code owner visibility checks should be performed
    * @param codeOwnerBackend the code owner backend from which the code owner config was loaded
@@ -721,7 +720,7 @@
    *     empty stream if there are no issues
    */
   public Stream<CommitValidationMessage> validateCodeOwnerConfig(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       RevWalk revWalk,
       IdentifiedUser user,
       CodeOwnerBackend codeOwnerBackend,
@@ -729,9 +728,12 @@
     requireNonNull(codeOwnerConfig, "codeOwnerConfig");
     return Streams.concat(
         validateCodeOwnerReferences(
-            project, user, codeOwnerBackend.getFilePath(codeOwnerConfig.key()), codeOwnerConfig),
+            branchNameKey,
+            user,
+            codeOwnerBackend.getFilePath(codeOwnerConfig.key()),
+            codeOwnerConfig),
         validateImports(
-            project,
+            branchNameKey,
             revWalk,
             codeOwnerBackend.getFilePath(codeOwnerConfig.key()),
             codeOwnerConfig));
@@ -740,7 +742,7 @@
   /**
    * Validates the code owner references of the given code owner config.
    *
-   * @param project the name of the project
+   * @param branchNameKey the branch and the project
    * @param user user for which the code owner visibility checks should be performed
    * @param codeOwnerConfigFilePath the path of the code owner config file which contains the code
    *     owner references
@@ -750,7 +752,7 @@
    *     empty stream if there are no issues
    */
   private Stream<CommitValidationMessage> validateCodeOwnerReferences(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       IdentifiedUser user,
       Path codeOwnerConfigFilePath,
       CodeOwnerConfig codeOwnerConfig) {
@@ -759,7 +761,7 @@
         .map(
             codeOwnerReference ->
                 validateCodeOwnerReference(
-                    project, user, codeOwnerConfigFilePath, codeOwnerReference))
+                    branchNameKey, user, codeOwnerConfigFilePath, codeOwnerReference))
         .filter(Optional::isPresent)
         .map(Optional::get);
   }
@@ -767,7 +769,7 @@
   /**
    * Validates a code owner reference.
    *
-   * @param project the name of the project
+   * @param branchNameKey the branch and the project
    * @param user user for which the code owner visibility checks should be performed
    * @param codeOwnerConfigFilePath the path of the code owner config file which contains the code
    *     owner reference
@@ -776,14 +778,14 @@
    *     Optional#empty()} if there is no issue
    */
   private Optional<CommitValidationMessage> validateCodeOwnerReference(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       IdentifiedUser user,
       Path codeOwnerConfigFilePath,
       CodeOwnerReference codeOwnerReference) {
     CodeOwnerResolver codeOwnerResolver = codeOwnerResolverProvider.get().forUser(user);
     if (!codeOwnerResolver.isEmailDomainAllowed(codeOwnerReference.email()).get()) {
       return nonResolvableCodeOwner(
-          project,
+          branchNameKey,
           String.format(
               "the domain of the code owner email '%s' in '%s' is not allowed for code owners",
               codeOwnerReference.email(), codeOwnerConfigFilePath));
@@ -801,7 +803,7 @@
     // cases so that uploaders cannot probe emails for existence (e.g. they cannot add an email and
     // conclude from the error message whether the email exists).
     return nonResolvableCodeOwner(
-        project,
+        branchNameKey,
         String.format(
             "code owner email '%s' in '%s' cannot be resolved for %s",
             codeOwnerReference.email(), codeOwnerConfigFilePath, user.getLoggableName()));
@@ -810,7 +812,7 @@
   /**
    * Validates the imports of the given code owner config.
    *
-   * @param project the name of the project
+   * @param branchNameKey the branch and the project
    * @param revWalk rev walk that should be used to load the code owner configs from {@code project}
    * @param codeOwnerConfigFilePath the path of the code owner config file which contains the code
    *     owner config
@@ -819,7 +821,7 @@
    *     if there are no issues
    */
   private Stream<CommitValidationMessage> validateImports(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       RevWalk revWalk,
       Path codeOwnerConfigFilePath,
       CodeOwnerConfig codeOwnerConfig) {
@@ -828,7 +830,7 @@
                 .map(
                     codeOwnerConfigReference ->
                         validateCodeOwnerConfigReference(
-                            project,
+                            branchNameKey,
                             revWalk,
                             codeOwnerConfigFilePath,
                             codeOwnerConfig.key(),
@@ -840,7 +842,7 @@
                 .map(
                     codeOwnerConfigReference ->
                         validateCodeOwnerConfigReference(
-                            project,
+                            branchNameKey,
                             revWalk,
                             codeOwnerConfigFilePath,
                             codeOwnerConfig.key(),
@@ -854,7 +856,7 @@
   /**
    * Validates a code owner config reference.
    *
-   * @param project the name of the project
+   * @param branchNameKey the branch and the project
    * @param revWalk rev walk that should be used to load the code owner configs from {@code project}
    * @param codeOwnerConfigFilePath the path of the code owner config file which contains the code
    *     owner config reference
@@ -867,7 +869,7 @@
    *     Optional#empty()} if there is no issue
    */
   private Optional<CommitValidationMessage> validateCodeOwnerConfigReference(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       RevWalk revWalk,
       Path codeOwnerConfigFilePath,
       CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
@@ -892,7 +894,7 @@
       // that uploaders cannot probe for the existence of projects (e.g. deduce from the error
       // message whether a project exists)
       return nonResolvableImport(
-          project,
+          branchNameKey,
           importType,
           codeOwnerConfigFilePath,
           String.format("project '%s' not found", keyOfImportedCodeOwnerConfig.project().get()));
@@ -900,7 +902,7 @@
 
     if (!projectState.get().statePermitsRead()) {
       return nonResolvableImport(
-          project,
+          branchNameKey,
           importType,
           codeOwnerConfigFilePath,
           String.format(
@@ -917,7 +919,7 @@
       // that uploaders cannot probe for the existence of branches (e.g. deduce from the error
       // message whether a branch exists)
       return nonResolvableImport(
-          project,
+          branchNameKey,
           importType,
           codeOwnerConfigFilePath,
           String.format(
@@ -933,7 +935,7 @@
     if (!codeOwnerBackend.isCodeOwnerConfigFile(
         keyOfImportedCodeOwnerConfig.project(), codeOwnerConfigReference.fileName())) {
       return nonResolvableImport(
-          project,
+          branchNameKey,
           importType,
           codeOwnerConfigFilePath,
           String.format(
@@ -945,13 +947,13 @@
       // walk, otherwise the revision may not be visible yet and trying to load a code owner config
       // from it could fail with MissingObjectException.
       Optional<CodeOwnerConfig> importedCodeOwnerConfig =
-          keyOfImportedCodeOwnerConfig.project().equals(project)
+          keyOfImportedCodeOwnerConfig.project().equals(branchNameKey.project())
               ? codeOwnerBackend.getCodeOwnerConfig(
                   keyOfImportedCodeOwnerConfig, revWalk, revision.get())
               : codeOwnerBackend.getCodeOwnerConfig(keyOfImportedCodeOwnerConfig, revision.get());
       if (!importedCodeOwnerConfig.isPresent()) {
         return nonResolvableImport(
-            project,
+            branchNameKey,
             importType,
             codeOwnerConfigFilePath,
             String.format(
@@ -965,7 +967,7 @@
       if (getInvalidConfigCause(codeOwnersInternalServerErrorException).isPresent()) {
         // The imported code owner config is non-parseable.
         return nonResolvableImport(
-            project,
+            branchNameKey,
             importType,
             codeOwnerConfigFilePath,
             String.format(
@@ -1047,7 +1049,7 @@
   }
 
   private Optional<CommitValidationMessage> nonResolvableImport(
-      Project.NameKey project,
+      BranchNameKey branchNameKey,
       CodeOwnerConfigImportType importType,
       Path codeOwnerConfigFilePath,
       String message) {
@@ -1055,7 +1057,9 @@
         importType,
         codeOwnerConfigFilePath,
         message,
-        codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableImports()
+        codeOwnersPluginConfiguration
+                .getProjectConfig(branchNameKey.project())
+                .rejectNonResolvableImports(branchNameKey.branch())
             ? ValidationMessage.Type.ERROR
             : ValidationMessage.Type.WARNING);
   }
@@ -1074,11 +1078,13 @@
   }
 
   private Optional<CommitValidationMessage> nonResolvableCodeOwner(
-      Project.NameKey project, String message) {
+      BranchNameKey branchNameKey, String message) {
     return Optional.of(
         new CommitValidationMessage(
             message,
-            codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableCodeOwners()
+            codeOwnersPluginConfiguration
+                    .getProjectConfig(branchNameKey.project())
+                    .rejectNonResolvableCodeOwners(branchNameKey.branch())
                 ? ValidationMessage.Type.ERROR
                 : ValidationMessage.Type.WARNING));
   }
diff --git a/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/CodeOwnerConfigValidatorIT.java b/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/CodeOwnerConfigValidatorIT.java
index b501277..c35280c 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/CodeOwnerConfigValidatorIT.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/CodeOwnerConfigValidatorIT.java
@@ -2007,6 +2007,98 @@
     assertThat(gApi.changes().id(r.getChangeId()).get().status).isEqualTo(ChangeStatus.MERGED);
   }
 
+  @Test
+  public void disableRejectionOfNonResolvableCodeOwnersForBranch() throws Exception {
+    setAsDefaultCodeOwners(admin);
+
+    // Disable the rejection of non-resolvable code owners for the master branch.
+    updateCodeOwnersConfig(
+        project,
+        codeOwnersConfig ->
+            codeOwnersConfig.setBoolean(
+                GeneralConfig.SECTION_VALIDATION,
+                "refs/heads/master",
+                GeneralConfig.KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+                false));
+
+    CodeOwnerConfig.Key codeOwnerConfigKey = createCodeOwnerConfigKey("/");
+    String unknownEmail = "non-existing-email@example.com";
+    PushOneCommit.Result r =
+        createChange(
+            "Add code owners",
+            codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getJGitFilePath(),
+            format(
+                CodeOwnerConfig.builder(codeOwnerConfigKey, TEST_REVISION)
+                    .addCodeOwnerSet(CodeOwnerSet.createWithoutPathExpressions(unknownEmail))
+                    .build()));
+    assertOkWithWarnings(
+        r,
+        "invalid code owner config files",
+        String.format(
+            "code owner email '%s' in '%s' cannot be resolved for %s",
+            unknownEmail,
+            codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath(),
+            identifiedUserFactory.create(admin.id()).getLoggableName()));
+
+    approve(r.getChangeId());
+    gApi.changes().id(r.getChangeId()).current().submit();
+    assertThat(gApi.changes().id(r.getChangeId()).get().status).isEqualTo(ChangeStatus.MERGED);
+  }
+
+  @Test
+  public void disableRejectionOfNonResolvableImportsForBranch() throws Exception {
+    skipTestIfImportsNotSupportedByCodeOwnersBackend();
+
+    setAsDefaultCodeOwners(admin);
+
+    // Disable the rejection of non-resolvable imports for the master branch.
+    updateCodeOwnersConfig(
+        project,
+        codeOwnersConfig ->
+            codeOwnersConfig.setBoolean(
+                GeneralConfig.SECTION_VALIDATION,
+                "refs/heads/master",
+                GeneralConfig.KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+                false));
+
+    // create a code owner config that imports a code owner config from a non-existing project
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig = createCodeOwnerConfigKey("/");
+    Project.NameKey nonExistingProject = Project.nameKey("non-existing");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        CodeOwnerConfigReference.builder(
+                CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
+                codeOwnerConfigOperations
+                    .codeOwnerConfig(CodeOwnerConfig.Key.create(nonExistingProject, "master", "/"))
+                    .getFilePath())
+            .setProject(nonExistingProject)
+            .build();
+    CodeOwnerConfig codeOwnerConfig =
+        createCodeOwnerConfigWithImport(
+            keyOfImportingCodeOwnerConfig,
+            CodeOwnerConfigImportType.GLOBAL,
+            codeOwnerConfigReference);
+
+    PushOneCommit.Result r =
+        createChange(
+            "Add code owners",
+            codeOwnerConfigOperations
+                .codeOwnerConfig(keyOfImportingCodeOwnerConfig)
+                .getJGitFilePath(),
+            format(codeOwnerConfig));
+    assertOkWithWarnings(
+        r,
+        "invalid code owner config files",
+        String.format(
+            "invalid %s import in '%s': project '%s' not found",
+            CodeOwnerConfigImportType.GLOBAL.getType(),
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).getFilePath(),
+            nonExistingProject.get()));
+
+    approve(r.getChangeId());
+    gApi.changes().id(r.getChangeId()).current().submit();
+    assertThat(gApi.changes().id(r.getChangeId()).get().status).isEqualTo(ChangeStatus.MERGED);
+  }
+
   private CodeOwnerConfig createCodeOwnerConfigWithImport(
       CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
       CodeOwnerConfigImportType importType,
diff --git a/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/PutCodeOwnerProjectConfigIT.java b/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/PutCodeOwnerProjectConfigIT.java
index 50114fe..5727b63 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/PutCodeOwnerProjectConfigIT.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/PutCodeOwnerProjectConfigIT.java
@@ -517,37 +517,52 @@
   @Test
   public void setRejectNonResolvableCodeOwners() throws Exception {
     assertThat(
-            codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableCodeOwners())
+            codeOwnersPluginConfiguration
+                .getProjectConfig(project)
+                .rejectNonResolvableCodeOwners("master"))
         .isTrue();
 
     CodeOwnerProjectConfigInput input = new CodeOwnerProjectConfigInput();
     input.rejectNonResolvableCodeOwners = false;
     projectCodeOwnersApiFactory.project(project).updateConfig(input);
     assertThat(
-            codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableCodeOwners())
+            codeOwnersPluginConfiguration
+                .getProjectConfig(project)
+                .rejectNonResolvableCodeOwners("master"))
         .isFalse();
 
     input.rejectNonResolvableCodeOwners = true;
     projectCodeOwnersApiFactory.project(project).updateConfig(input);
     assertThat(
-            codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableCodeOwners())
+            codeOwnersPluginConfiguration
+                .getProjectConfig(project)
+                .rejectNonResolvableCodeOwners("master"))
         .isTrue();
   }
 
   @Test
   public void setRejectNonResolvableImports() throws Exception {
-    assertThat(codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableImports())
+    assertThat(
+            codeOwnersPluginConfiguration
+                .getProjectConfig(project)
+                .rejectNonResolvableImports("master"))
         .isTrue();
 
     CodeOwnerProjectConfigInput input = new CodeOwnerProjectConfigInput();
     input.rejectNonResolvableImports = false;
     projectCodeOwnersApiFactory.project(project).updateConfig(input);
-    assertThat(codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableImports())
+    assertThat(
+            codeOwnersPluginConfiguration
+                .getProjectConfig(project)
+                .rejectNonResolvableImports("master"))
         .isFalse();
 
     input.rejectNonResolvableImports = true;
     projectCodeOwnersApiFactory.project(project).updateConfig(input);
-    assertThat(codeOwnersPluginConfiguration.getProjectConfig(project).rejectNonResolvableImports())
+    assertThat(
+            codeOwnersPluginConfiguration
+                .getProjectConfig(project)
+                .rejectNonResolvableImports("master"))
         .isTrue();
   }
 
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshotTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshotTest.java
index eff2303..81a9022 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshotTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/config/CodeOwnersPluginConfigSnapshotTest.java
@@ -1101,6 +1101,143 @@
         .isEqualTo(CodeOwnerConfigValidationPolicy.DRY_RUN);
   }
 
+  @Test
+  public void cannotGetRejectNonResolvableCodeOwnersForNullBranch() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () -> cfgSnapshot().rejectNonResolvableCodeOwners(/* branchName= */ null));
+    assertThat(npe).hasMessageThat().isEqualTo("branchName");
+  }
+
+  @Test
+  public void getRejectNonResolvableCodeOwners_notConfigured() throws Exception {
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("non-existing")).isTrue();
+  }
+
+  @Test
+  public void getRejectNonResolvableCodeOwners_configuredOnProjectLevel() throws Exception {
+    configureRejectNonResolvableCodeOwners(project, false);
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("master")).isFalse();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("non-existing")).isFalse();
+  }
+
+  @Test
+  public void getRejectNonResolvableCodeOwners_configuredOnBranchLevel() throws Exception {
+    configureRejectNonResolvableCodeOwnersForBranch(project, "refs/heads/master", false);
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("master")).isFalse();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("refs/heads/master")).isFalse();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("foo")).isTrue();
+  }
+
+  @Test
+  public void getRejectNonResolvableCodeOwners_branchLevelConfigTakesPrecedence() throws Exception {
+    updateCodeOwnersConfig(
+        project,
+        codeOwnersConfig -> {
+          codeOwnersConfig.setBoolean(
+              CodeOwnersPluginConfiguration.SECTION_CODE_OWNERS,
+              /* subsection= */ null,
+              GeneralConfig.KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+              /* value= */ false);
+          codeOwnersConfig.setBoolean(
+              GeneralConfig.SECTION_VALIDATION,
+              "refs/heads/master",
+              GeneralConfig.KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+              /* value= */ true);
+        });
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("refs/heads/master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("foo")).isFalse();
+  }
+
+  @Test
+  public void getRejectNonResolvableCodeOwners_inheritedBranchLevelConfigTakesPrecedence()
+      throws Exception {
+    configureRejectNonResolvableCodeOwnersForBranch(allProjects, "refs/heads/master", true);
+    configureRejectNonResolvableCodeOwners(project, false);
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("refs/heads/master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("foo")).isFalse();
+  }
+
+  @Test
+  public void getRejectNonResolvableCodeOwners_inheritedBranchLevelCanBeOverridden()
+      throws Exception {
+    configureRejectNonResolvableCodeOwnersForBranch(allProjects, "refs/heads/master", true);
+    configureRejectNonResolvableCodeOwnersForBranch(project, "refs/heads/master", false);
+    assertThat(cfgSnapshot().rejectNonResolvableCodeOwners("master")).isFalse();
+  }
+
+  @Test
+  public void cannotGetRejectNonResolvableImportsForNullBranch() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () -> cfgSnapshot().rejectNonResolvableImports(/* branchName= */ null));
+    assertThat(npe).hasMessageThat().isEqualTo("branchName");
+  }
+
+  @Test
+  public void getRejectNonResolvableImports_notConfigured() throws Exception {
+    assertThat(cfgSnapshot().rejectNonResolvableImports("master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("non-existing")).isTrue();
+  }
+
+  @Test
+  public void getRejectNonResolvableImports_configuredOnProjectLevel() throws Exception {
+    configureRejectNonResolvableImports(project, false);
+    assertThat(cfgSnapshot().rejectNonResolvableImports("master")).isFalse();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("non-existing")).isFalse();
+  }
+
+  @Test
+  public void getRejectNonResolvableImports_configuredOnBranchLevel() throws Exception {
+    configureRejectNonResolvableImportsForBranch(project, "refs/heads/master", false);
+    assertThat(cfgSnapshot().rejectNonResolvableImports("master")).isFalse();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("refs/heads/master")).isFalse();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("foo")).isTrue();
+  }
+
+  @Test
+  public void getRejectNonResolvableImports_branchLevelConfigTakesPrecedence() throws Exception {
+    updateCodeOwnersConfig(
+        project,
+        codeOwnersConfig -> {
+          codeOwnersConfig.setBoolean(
+              CodeOwnersPluginConfiguration.SECTION_CODE_OWNERS,
+              /* subsection= */ null,
+              GeneralConfig.KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+              /* value= */ false);
+          codeOwnersConfig.setBoolean(
+              GeneralConfig.SECTION_VALIDATION,
+              "refs/heads/master",
+              GeneralConfig.KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+              /* value= */ true);
+        });
+    assertThat(cfgSnapshot().rejectNonResolvableImports("master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("refs/heads/master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("foo")).isFalse();
+  }
+
+  @Test
+  public void getRejectNonResolvableImports_inheritedBranchLevelConfigTakesPrecedence()
+      throws Exception {
+    configureRejectNonResolvableImportsForBranch(allProjects, "refs/heads/master", true);
+    configureRejectNonResolvableImports(project, false);
+    assertThat(cfgSnapshot().rejectNonResolvableImports("master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("refs/heads/master")).isTrue();
+    assertThat(cfgSnapshot().rejectNonResolvableImports("foo")).isFalse();
+  }
+
+  @Test
+  public void getRejectNonResolvableImports_inheritedBranchLevelCanBeOverridden() throws Exception {
+    configureRejectNonResolvableImportsForBranch(allProjects, "refs/heads/master", true);
+    configureRejectNonResolvableImportsForBranch(project, "refs/heads/master", false);
+    assertThat(cfgSnapshot().rejectNonResolvableImports("master")).isFalse();
+  }
+
   private CodeOwnersPluginConfigSnapshot cfgSnapshot() {
     return codeOwnersPluginConfigSnapshotFactory.create(project);
   }
@@ -1238,6 +1375,48 @@
                 codeOwnerConfigValidationPolicy.name()));
   }
 
+  private void configureRejectNonResolvableCodeOwners(Project.NameKey project, boolean value)
+      throws Exception {
+    setCodeOwnersConfig(
+        project,
+        /* subsection= */ null,
+        GeneralConfig.KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        Boolean.toString(value));
+  }
+
+  private void configureRejectNonResolvableCodeOwnersForBranch(
+      Project.NameKey project, String branchSubsection, boolean value) throws Exception {
+    updateCodeOwnersConfig(
+        project,
+        codeOwnersConfig ->
+            codeOwnersConfig.setString(
+                GeneralConfig.SECTION_VALIDATION,
+                branchSubsection,
+                GeneralConfig.KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+                Boolean.toString(value)));
+  }
+
+  private void configureRejectNonResolvableImports(Project.NameKey project, boolean value)
+      throws Exception {
+    setCodeOwnersConfig(
+        project,
+        /* subsection= */ null,
+        GeneralConfig.KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        Boolean.toString(value));
+  }
+
+  private void configureRejectNonResolvableImportsForBranch(
+      Project.NameKey project, String branchSubsection, boolean value) throws Exception {
+    updateCodeOwnersConfig(
+        project,
+        codeOwnersConfig ->
+            codeOwnersConfig.setString(
+                GeneralConfig.SECTION_VALIDATION,
+                branchSubsection,
+                GeneralConfig.KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+                Boolean.toString(value)));
+  }
+
   private AutoCloseable registerTestBackend() {
     RegistrationHandle registrationHandle =
         ((PrivateInternals_DynamicMapImpl<CodeOwnerBackend>) codeOwnerBackends)
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfigTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfigTest.java
index 3c9fc09..5b5b6e9 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfigTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/config/GeneralConfigTest.java
@@ -281,6 +281,185 @@
   }
 
   @Test
+  public void cannotGetRejectNonResolvableCodeOwnersForBranchForNullBranch() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                    /* branchNameKey= */ null, new Config()));
+    assertThat(npe).hasMessageThat().isEqualTo("branchNameKey");
+  }
+
+  @Test
+  public void cannotGetRejectNonResolvableCodeOwnersForBranchForNullConfig() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                    BranchNameKey.create(project, "master"), /* pluginConfig= */ null));
+    assertThat(npe).hasMessageThat().isEqualTo("pluginConfig");
+  }
+
+  @Test
+  public void noBranchSpecificRejectNonResolvableCodeOwnersConfiguration() throws Exception {
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), new Config()))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_exact()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/foo",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_refPattern()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/foo/*",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_regEx()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/.*foo.*",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_invalidRegEx()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/[",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void matchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_exact()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/master",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
+  public void matchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_refPattern()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/*",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
+  public void matchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration_regEx()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/.*bar.*",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "foobarbaz"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
+  public void branchSpecificRejectNonResolvableCodeOwnersConfigurationIsIgnoredIfValueIsInvalid()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setString(
+        SECTION_VALIDATION, "refs/heads/master", KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS, "INVALID");
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void multipleMatchingBranchSpecificRejectNonResolvableCodeOwnersConfiguration()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/master",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/*",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/.*",
+        KEY_REJECT_NON_RESOLVABLE_CODE_OWNERS,
+        /* value= */ false);
+
+    // it is non-deterministic which of the branch-specific configurations takes precedence, but
+    // since they all configure the same value it's not important for this assertion
+    assertThat(
+            generalConfig.getRejectNonResolvableCodeOwnersForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
   public void cannotGetRejectNonResolvableImportsForNullProject() throws Exception {
     NullPointerException npe =
         assertThrows(
@@ -339,6 +518,176 @@
   }
 
   @Test
+  public void cannotGetRejectNonResolvableImportsForBranchForNullBranch() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                generalConfig.getRejectNonResolvableImportsForBranch(
+                    /* branchNameKey= */ null, new Config()));
+    assertThat(npe).hasMessageThat().isEqualTo("branchNameKey");
+  }
+
+  @Test
+  public void cannotGetRejectNonResolvableImportsForBranchForNullConfig() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                generalConfig.getRejectNonResolvableImportsForBranch(
+                    BranchNameKey.create(project, "master"), /* pluginConfig= */ null));
+    assertThat(npe).hasMessageThat().isEqualTo("pluginConfig");
+  }
+
+  @Test
+  public void noBranchSpecificRejectNonResolvableImportsConfiguration() throws Exception {
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), new Config()))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableImportsConfiguration_exact()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/foo",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableImportsConfiguration_refPattern()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/foo/*",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableImportsConfiguration_regEx()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/.*foo.*",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void noMatchingBranchSpecificRejectNonResolvableImportsConfiguration_invalidRegEx()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION, "^refs/heads/[", KEY_REJECT_NON_RESOLVABLE_IMPORTS, /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void matchingBranchSpecificRejectNonResolvableImportsConfiguration_exact()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/master",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
+  public void matchingBranchSpecificRejectNonResolvableImportsConfiguration_refPattern()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION, "refs/heads/*", KEY_REJECT_NON_RESOLVABLE_IMPORTS, /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
+  public void matchingBranchSpecificRejectNonResolvableImportsConfiguration_regEx()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/.*bar.*",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "foobarbaz"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
+  public void branchSpecificRejectNonResolvableImportsConfigurationIsIgnoredIfValueIsInvalid()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setString(
+        SECTION_VALIDATION, "refs/heads/master", KEY_REJECT_NON_RESOLVABLE_IMPORTS, "INVALID");
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .isEmpty();
+  }
+
+  @Test
+  public void multipleMatchingBranchSpecificRejectNonResolvableImportsConfiguration()
+      throws Exception {
+    Config cfg = new Config();
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "refs/heads/master",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+    cfg.setBoolean(
+        SECTION_VALIDATION, "refs/heads/*", KEY_REJECT_NON_RESOLVABLE_IMPORTS, /* value= */ false);
+    cfg.setBoolean(
+        SECTION_VALIDATION,
+        "^refs/heads/.*",
+        KEY_REJECT_NON_RESOLVABLE_IMPORTS,
+        /* value= */ false);
+
+    // it is non-deterministic which of the branch-specific configurations takes precedence, but
+    // since they all configure the same value it's not important for this assertion
+    assertThat(
+            generalConfig.getRejectNonResolvableImportsForBranch(
+                BranchNameKey.create(project, "master"), cfg))
+        .value()
+        .isEqualTo(false);
+  }
+
+  @Test
   public void cannotGetEnableValidationOnCommitReceivedForNullProject() throws Exception {
     NullPointerException npe =
         assertThrows(
diff --git a/resources/Documentation/config.md b/resources/Documentation/config.md
index 70e5630..9dbb6a4 100644
--- a/resources/Documentation/config.md
+++ b/resources/Documentation/config.md
@@ -673,10 +673,27 @@
         [plugin.@PLUGIN@.rejectNonResolvableCodeOwners](#pluginCodeOwnersRejectNonResolvableCodeOwners)
         in `gerrit.config` and the `codeOwners.rejectNonResolvableCodeOwners`
         setting from parent projects.\
+        Can be overriden on branch-level by setting
+        [validation.\<branch\>.rejectNonResolvableCodeOwners](#validationBranchRejectNonResolvableCodeOwners).\
         If not set, the global setting
         [plugin.@PLUGIN@.rejectNonResolvableCodeOwners](#pluginCodeOwnersRejectNonResolvableCodeOwners)
         in `gerrit.config` is used.
 
+<a id="validationBranchRejectNonResolvableCodeOwners">validation.\<branch\>.rejectNonResolvableCodeOwners</a>
+:       Branch-level configuration to control whether modifications of code
+        owner config files that newly add non-resolvable code owners should be
+        rejected on commit received and submit.\
+        Applies to all branches that are matched by `<branch>`, which can be
+        an exact ref name (e.g. `refs/heads/master`), a ref pattern (e.g.
+        `refs/heads/*`) or a regular expression (e.g. `^refs/heads/stable-.*`).\
+        If a branches matches multiple validation subsections it is undefined
+        which of the subsections takes precedence.\
+        Overrides the project-level configuration for rejecting non-resolvable
+        code owners that is configured by
+        [codeOwners.rejectNonResolvableCodeOwners](#codeOwnersRejectNonResolvableCodeOwners).\
+        For further details see the description of
+        [codeOwners.rejectNonResolvableCodeOwners](#codeOwnersRejectNonResolvableCodeOwners).
+
 <a id="codeOwnersRejectNonResolvableImports">codeOwners.rejectNonResolvableImports</a>
 :       Whether modifications of code owner config files that newly add
         non-resolvable imports should be rejected on commit received an submit.\
@@ -691,10 +708,27 @@
         [plugin.@PLUGIN@.rejectNonResolvableImports](#pluginCodeOwnersRejectNonResolvableImports)
         in `gerrit.config` and the `codeOwners.rejectNonResolvableImports`
         setting from parent projects.\
+        Can be overriden on branch-level by setting
+        [validation.\<branch\>.rejectNonResolvableImports](#validationBranchRejectNonResolvableImports).\
         If not set, the global setting
         [plugin.@PLUGIN@.rejectNonResolvableImports](#pluginCodeOwnersRejectNonResolvableImports)
         in `gerrit.config` is used.
 
+<a id="validationBranchRejectNonResolvableImports">validation.\<branch\>.rejectNonResolvableImports</a>
+:       Branch-level configuration to control whether modifications of code
+        owner config files that newly add non-resolvable imports should be
+        rejected on commit received and submit.\
+        Applies to all branches that are matched by `<branch>`, which can be
+        an exact ref name (e.g. `refs/heads/master`), a ref pattern (e.g.
+        `refs/heads/*`) or a regular expression (e.g. `^refs/heads/stable-.*`).\
+        If a branches matches multiple validation subsections it is undefined
+        which of the subsections takes precedence.\
+        Overrides the project-level configuration for rejecting non-resolvable
+        imports that is configured by
+        [codeOwners.rejectNonResolvableImports](#codeOwnersRejectNonResolvableImports).\
+        For further details see the description of
+        [codeOwners.rejectNonResolvableImports](#codeOwnersRejectNonResolvableImports).
+
 <a id="codeOwnersRequiredApproval">codeOwners.requiredApproval</a>
 :       Approval that is required from code owners to approve the files in a
         change.\