diff --git a/api/src/certification/enrolment/domain/usecases/verify-candidate-subscriptions.js b/api/src/certification/enrolment/domain/usecases/verify-candidate-subscriptions.js
index 696f6894e9a..4ea1d3ac690 100644
--- a/api/src/certification/enrolment/domain/usecases/verify-candidate-subscriptions.js
+++ b/api/src/certification/enrolment/domain/usecases/verify-candidate-subscriptions.js
@@ -19,7 +19,10 @@ import { CertificationCandidateEligibilityError } from '../errors.js';
  * @param {ComplementaryCertificationBadgeRepository} params.complementaryCertificationBadgeRepository
  * @param {PlacementProfileService} params.placementProfileService
  * @param {CertificationBadgesService} params.certificationBadgesService
- * @returns {Promise<void>}
+ *
+ * @returns {Promise<void>} if candidate is deemed eligible
+ * @throws {UserNotAuthorizedToCertifyError} candidate is not certifiable for CORE
+ * @throws {CertificationCandidateEligibilityError} candidate is not eligibile to his complementary
  */
 export async function verifyCandidateSubscriptions({
   candidate,
@@ -173,7 +176,13 @@ function _isUserPixScoreSufficientForBadge({
 }
 
 function _computeRequiredScore({ lowerLevelBadge, subscribedComplementaryCertificationBadge }) {
-  return lowerLevelBadge
-    ? lowerLevelBadge.minimumEarnedPix
-    : subscribedComplementaryCertificationBadge.minimumEarnedPix;
+  if (lowerLevelBadge?.minimumEarnedPix) {
+    return lowerLevelBadge.minimumEarnedPix;
+  }
+
+  if (subscribedComplementaryCertificationBadge?.minimumEarnedPix) {
+    return subscribedComplementaryCertificationBadge.minimumEarnedPix;
+  }
+
+  return 0;
 }
diff --git a/api/tests/certification/enrolment/unit/domain/usecases/verify-candidate-subscriptions_test.js b/api/tests/certification/enrolment/unit/domain/usecases/verify-candidate-subscriptions_test.js
index 4516f3f0244..f6346aec014 100644
--- a/api/tests/certification/enrolment/unit/domain/usecases/verify-candidate-subscriptions_test.js
+++ b/api/tests/certification/enrolment/unit/domain/usecases/verify-candidate-subscriptions_test.js
@@ -113,13 +113,13 @@ describe('Certification | Enrolment | Unit | Domain | UseCase | verify-candidate
 
         // when
         // then
-        expect(async () => {
-          await verifyCandidateSubscriptions({
+        return expect(
+          verifyCandidateSubscriptions({
             userId: 2,
             candidate,
             ...dependencies,
-          });
-        }).not.to.throw(CertificationCandidateEligibilityError);
+          }),
+        ).to.be.fulfilled;
       });
     });
 
@@ -144,13 +144,13 @@ describe('Certification | Enrolment | Unit | Domain | UseCase | verify-candidate
 
         // when
         //then
-        expect(async () => {
-          await verifyCandidateSubscriptions({
+        return expect(
+          verifyCandidateSubscriptions({
             userId: 2,
             candidate,
             ...dependencies,
-          });
-        }).not.to.throw(CertificationCandidateEligibilityError);
+          }),
+        ).to.be.fulfilled;
       });
     });
 
@@ -419,67 +419,136 @@ describe('Certification | Enrolment | Unit | Domain | UseCase | verify-candidate
       });
 
       context('when user pixScore is above current level', function () {
-        it('should resolve', async function () {
-          // given
-          const certificationCandidateId = 456;
-          const complementaryCertificationId = 789;
-          const complementaryCertificationBadgeId = 4568;
+        context('when there is a minimumEarnedPix', function () {
+          it('should not reject the candidate', async function () {
+            // given
+            const certificationCandidateId = 456;
+            const complementaryCertificationId = 789;
+            const complementaryCertificationBadgeId = 4568;
+
+            const candidate = domainBuilder.certification.enrolment.buildCandidate({
+              id: certificationCandidateId,
+              userId: 1234,
+              subscriptions: [
+                domainBuilder.certification.enrolment.buildComplementarySubscription({
+                  certificationCandidateId,
+                  complementaryCertificationId,
+                }),
+              ],
+            });
 
-          const candidate = domainBuilder.certification.enrolment.buildCandidate({
-            id: certificationCandidateId,
-            userId: 1234,
-            subscriptions: [
-              domainBuilder.certification.enrolment.buildComplementarySubscription({
-                certificationCandidateId,
+            const complementaryCertificationBadges = [
+              domainBuilder.certification.complementary.buildComplementaryCertificationBadge({
+                id: complementaryCertificationBadgeId,
                 complementaryCertificationId,
+                level: 1,
+                minimumEarnedPix: 200,
               }),
-            ],
+            ];
+
+            dependencies.pixCertificationRepository.findByUserId.resolves([
+              domainBuilder.certification.enrolment.buildPixCertification({
+                pixScore: 300,
+                status: AssessmentResult.status.VALIDATED,
+                isCancelled: false,
+                isRejectedForFraud: false,
+              }),
+            ]);
+
+            dependencies.certificationBadgesService.findLatestBadgeAcquisitions.resolves([
+              domainBuilder.buildCertifiableBadgeAcquisition({
+                complementaryCertificationId,
+                complementaryCertificationBadgeId,
+              }),
+            ]);
+
+            dependencies.complementaryCertificationBadgeRepository.findAll.resolves([
+              ...complementaryCertificationBadges,
+              domainBuilder.certification.complementary.buildComplementaryCertificationBadge({
+                id: 9865,
+                level: 1,
+                minimumEarnedPix: 300,
+                complementaryCertificationId: 9865,
+              }),
+            ]);
+
+            // when
+            //then
+            return expect(
+              verifyCandidateSubscriptions({
+                userId: candidate.userId,
+                candidate,
+                ...dependencies,
+              }),
+            ).to.be.fulfilled;
           });
+        });
 
-          const complementaryCertificationBadges = [
-            domainBuilder.certification.complementary.buildComplementaryCertificationBadge({
-              id: complementaryCertificationBadgeId,
-              complementaryCertificationId,
-              level: 1,
-              minimumEarnedPix: 200,
-            }),
-          ];
+        context('when minimumEarnedPix is undefined', function () {
+          it('should not reject the candidate', async function () {
+            // given
+            const certificationCandidateId = 456;
+            const complementaryCertificationId = 789;
+            const complementaryCertificationBadgeId = 4568;
+
+            const candidate = domainBuilder.certification.enrolment.buildCandidate({
+              id: certificationCandidateId,
+              userId: 1234,
+              subscriptions: [
+                domainBuilder.certification.enrolment.buildComplementarySubscription({
+                  certificationCandidateId,
+                  complementaryCertificationId,
+                }),
+              ],
+            });
 
-          dependencies.pixCertificationRepository.findByUserId.resolves([
-            domainBuilder.certification.enrolment.buildPixCertification({
-              pixScore: 300,
-              status: AssessmentResult.status.VALIDATED,
-              isCancelled: false,
-              isRejectedForFraud: false,
-            }),
-          ]);
+            const complementaryCertificationBadges = [
+              domainBuilder.certification.complementary.buildComplementaryCertificationBadge({
+                id: complementaryCertificationBadgeId,
+                complementaryCertificationId,
+                level: 1,
+              }),
+            ];
 
-          dependencies.certificationBadgesService.findLatestBadgeAcquisitions.resolves([
-            domainBuilder.buildCertifiableBadgeAcquisition({
-              complementaryCertificationId,
-              complementaryCertificationBadgeId,
-            }),
-          ]);
+            // DomainBuilder does not allow a undefined value, and 'null' is a value that is already handled
+            delete complementaryCertificationBadges[0].minimumEarnedPix;
 
-          dependencies.complementaryCertificationBadgeRepository.findAll.resolves([
-            ...complementaryCertificationBadges,
-            domainBuilder.certification.complementary.buildComplementaryCertificationBadge({
-              id: 9865,
-              level: 1,
-              minimumEarnedPix: 300,
-              complementaryCertificationId: 9865,
-            }),
-          ]);
+            dependencies.pixCertificationRepository.findByUserId.resolves([
+              domainBuilder.certification.enrolment.buildPixCertification({
+                pixScore: 300,
+                status: AssessmentResult.status.VALIDATED,
+                isCancelled: false,
+                isRejectedForFraud: false,
+              }),
+            ]);
 
-          // when
-          //then
-          expect(async () => {
-            await verifyCandidateSubscriptions({
-              userId: candidate.userId,
-              candidate,
-              ...dependencies,
-            });
-          }).not.to.throw(CertificationCandidateEligibilityError);
+            dependencies.certificationBadgesService.findLatestBadgeAcquisitions.resolves([
+              domainBuilder.buildCertifiableBadgeAcquisition({
+                complementaryCertificationId,
+                complementaryCertificationBadgeId,
+              }),
+            ]);
+
+            dependencies.complementaryCertificationBadgeRepository.findAll.resolves([
+              ...complementaryCertificationBadges,
+              domainBuilder.certification.complementary.buildComplementaryCertificationBadge({
+                id: 9865,
+                level: 1,
+                minimumEarnedPix: 300,
+                complementaryCertificationId: 9865,
+              }),
+            ]);
+
+            // when
+            //then
+            return expect(
+              verifyCandidateSubscriptions({
+                userId: candidate.userId,
+                candidate,
+                ...dependencies,
+              }),
+            ).to.be.fulfilled;
+          });
         });
       });
     });