Developer ID Certification Authority 2026: Certificate Migration Acceptance Checklist
Apple says the original Developer ID Certification Authority Sub-CA expires on February 1, 2027. Decision: verify the issuer first, replace affected signing identities with G2, then test each release artifact separately. A safely timestamped, notarized Mac app can remain usable; an affected .pkg must be re-signed before the deadline, and future app updates should use the new certificate.
This guide is for independent developers distributing macOS apps who need to identify an affected certificate and plan updates.
It also covers developers maintaining .pkg installers and teams signing from a remote Mac or automated job.
Last updated October 3, 2026. Dates, certificate guidance, and artifact behavior were checked against Apple’s expiry announcement and certificate replacement instructions.
Verify the issuer before classifying a certificate
A certificate’s friendly name tells you its purpose, not necessarily which issuing authority signed it. A name such as “Developer ID Application” or “Developer ID Installer” is not enough to establish whether it belongs to the expiring chain. Check the issuer and certificate chain, then compare that evidence with the certificate options and replacement guidance in your Apple Developer account.
For the same reason, the expiration date alone is not a reliable migration test. It can help locate a certificate that needs review, but it does not establish which Sub-CA issued it. Record the certificate identity, issuer details, intended use, and where its private key is available.
| Check | Legacy Sub-CA evidence | G2 replacement evidence | Decision |
|---|---|---|---|
| Certificate purpose | Developer ID Application or Developer ID Installer | The corresponding Application or Installer purpose | Confirm which artifact the identity signs |
| Issuer and chain | Chain identifies the original Developer ID Certification Authority Sub-CA | Chain identifies the G2 Sub-CA described in Apple’s replacement instructions | Compare issuer and chain, not just the displayed identity name |
| Account evidence | Existing certificate details in the developer account | The G2 option selected when creating a replacement | Keep a record of the account selection and issued certificate |
| Key availability | Certificate may appear without a usable private key on the build machine | Replacement certificate and matching private key are available to the signing identity | A certificate without its private key cannot sign |
The table is a decision aid, not a substitute for the account’s certificate details. Apple’s instructions for replacing Developer ID certificates are the authority for identifying the G2 Sub-CA choice. Apple also explains how to create Developer ID certificates. If the account page and the certificate chain do not match your expectation, do not infer the issuer from a shortened name in a signing dialog. Pause and resolve the discrepancy before changing the release pipeline.
How can you tell whether a Developer ID certificate uses the old Sub-CA?
Inspect the certificate itself and its chain in the developer account and in the keychain used for signing. Compare the issuer information with Apple’s replacement guidance: the old chain is associated with the original Developer ID Certification Authority Sub-CA, while the replacement path specifies the G2 Sub-CA. The displayed signing identity describes its role, such as Application or Installer; it is not issuer proof.
Apple’s code-signing certificate technical note provides context for inspecting certificates and their chains. Preserve a screenshot or exported certificate details for the inventory. That gives the release owner evidence they can revisit when a build machine, keychain, or signing job changes.
Do not mark a certificate “migrated” because a G2 certificate exists in the account. The build must use the intended identity, and its private key must be available in the environment that actually signs the release.
Separate app and installer impact
The deadline does not produce one universal outcome for every item in a release folder. Apple distinguishes existing notarized Mac software from .pkg installers signed with an affected certificate. The action also differs for an app already distributed and for a future update.
| Release item | Apple’s stated impact | Migration decision |
|---|---|---|
| Existing Mac app with a secure timestamp and completed notarization | Continues to work | Keep release records; do not re-sign solely because the old authority is expiring |
| Future update to a Mac app | Should use a new certificate and include a secure timestamp | Move the update’s signing identity to G2 and validate the final app |
| .pkg signed with an affected certificate | Cannot be installed after the old Sub-CA expires on February 1, 2027 | Re-sign the package with an appropriate replacement identity before the deadline and test installation |
These are Apple’s stated platform outcomes, not a prediction based on a certificate’s displayed expiry date. See the expiry announcement for the deadline and the distinction between existing notarized apps and affected packages.
Does an existing macOS app need to be signed again after a G2 replacement?
Not solely because the old Sub-CA is expiring if the existing app has a secure timestamp and has been notarized. Apple says such existing software continues to work. That is different from the next update: plan to sign future updates with the replacement certificate and include a secure timestamp. Verify your own release record rather than assuming that every app has the required timestamp and notarization.
When does an old-certificate .pkg stop installing?
Apple states that a .pkg signed with a certificate from the expiring Sub-CA will not install after February 1, 2027. Treat that as a release cutoff: identify the package’s actual signing identity, create and use the appropriate replacement, then verify the final package. A successful build alone is not proof that the installer was re-signed.
An installer signature and an app signature serve different purposes. A package can contain a signed app, but that does not mean the package itself has the required Developer ID Installer signature. Keep the package and the app inside it as separate acceptance objects.
Match each certificate to the artifact it signs
Developer ID Application and Developer ID Installer are not interchangeable. The first signs a macOS app or other code intended for distribution; the second signs the installer package. A team that only replaces its Application identity may still be preparing an affected .pkg with the old Installer identity.
| Identity | Primary artifact to check | Migration evidence |
|---|---|---|
| Developer ID Application | The final app bundle and its signed code | G2 issuer chain, matching private key, and a signature check on the release artifact |
| Developer ID Installer | The final .pkg file | G2 issuer chain, matching private key, and a package signature check |
| Both identities | A release that distributes an app inside a signed .pkg | Separate evidence for the app and package; do not treat one identity as covering both |
Use Apple’s Developer ID certificate creation guidance to choose the certificate type for the artifact. Then verify the certificate’s issuer. Selecting the right label in the account is only one part of the decision; the installed certificate and private key must also be the ones your signing command can access.
A useful inventory records the identity’s purpose, issuer chain, private-key availability, keychain location, signing job, and release artifacts that consume it. If a certificate is shared across machines or jobs, record each consumer rather than assuming one machine’s setup represents the entire release process.
Check that the signing environment can use G2
A certificate can be correct in the account yet unavailable to the process that builds the release. This commonly happens when a developer imports credentials into a desktop keychain but a scheduled task or SSH session runs under a different account, or when an automated job selects another keychain. The visible login session and the signing process must be checked independently.
For a local Mac, confirm that the expected certificate and matching private key appear in the keychain used by the signing account. Run a test from the same user context that performs the release build. If the release is signed through a graphical tool, inspect that tool’s signing selection; if it is signed by a shell script or automated job, inspect the environment and command it actually invokes.
For a remote Mac, repeat those checks over the access method and execution identity used for release work. A certificate visible in an interactive desktop session does not prove it is available to an SSH command or a background task. Remote environments also differ in how credentials are delivered and which keychain is accessible; confirm those details for the specific host rather than assuming a single setup applies everywhere.
How do you confirm a remote Mac used the new Developer ID certificate?
Run the signing verification against the final artifact from the same remote Mac and execution context that produced it. Capture the command output, the certificate issuer or chain evidence, the selected identity, and the build log that ties the artifact to that job. If the remote task still resolves to the old identity, or cannot access the G2 private key, the migration is not ready even if a separate desktop session shows the new certificate.
Do not transfer private keys or signing assets into a remote environment until the team has decided who controls them, who can access the host, and how access will be removed. This checklist does not imply that every remote Mac provides the same credential-import method or certificate-handling service.
Validate the final app and package
Acceptance evidence should describe the artifact that will actually be distributed, not just a successful certificate installation. Keep the verification repeatable: retain the release artifact, signing output, relevant notarization evidence, and the identity details used for the build.
For a Mac app update, inspect the signature on the final app bundle and confirm that it resolves to the intended Developer ID Application identity. Apple’s notarization preparation guidance explains the requirements to consider before distributing notarized software. If notarization fails, use Apple’s common notarization issues guidance to investigate the failure rather than treating a local signature check as proof of notarization.
For a .pkg, inspect the signature on the final package separately and test the installation path used by your release. A signed package that was not tested after migration may still contain an unexpected identity, an incomplete package, or a packaging step that uses an old keychain. If a package contains an app, validate the app and the package as distinct layers.
Apple’s code-signing guidance documents certificate inspection, while the package tooling can report the signature associated with an installer. A team may use commands such as codesign -dv --verbose=4 to inspect an app signature and pkgutil --check-signature to check a package signature. Run them against the release artifacts, retain the output, and compare the reported identity with the G2 certificate evidence. Do not treat a command’s successful exit alone as proof that the intended certificate was selected.
Declare migration readiness from evidence
Use this acceptance list for each release channel. Mark an item complete only when its evidence can be reviewed by someone other than the person who changed the signing setup.
- [ ] The Developer ID Application and Developer ID Installer identities are inventoried separately.
- [ ] The issuer and chain for each relevant certificate have been checked; the displayed identity name was not used as the sole proof.
- [ ] Every affected identity has a documented G2 replacement decision based on the account options and issuer verification.
- [ ] The matching private key is available to the actual signing account and task, not merely visible in another session.
- [ ] The final app update was checked for the intended Application identity and the required timestamp and notarization status.
- [ ] The final .pkg was checked for the intended Installer identity and installation was tested using the release’s distribution path.
- [ ] Build logs and signature evidence identify the artifact and signing environment that produced it.
- [ ] A release owner is responsible for tracking future certificate renewal and repeating these checks.
If the issuer is unclear, the private key is missing, or a build still selects the old certificate, do not declare the migration complete. Resolve the identity or environment gap and repeat artifact verification. This is a release acceptance decision, not a general certificate-expiry recovery procedure.
For teams currently signing on a personal Mac, the main operational risks are a keychain tied to one person’s account, a machine that is unavailable when a release must be rebuilt, and a mismatch between interactive and automated signing contexts. A hosted build environment can add its own constraints, such as limited access to the signing session or a different credential lifecycle. A dedicated local Mac avoids some remote-access dependencies but brings hardware ownership and maintenance. None of these options removes the need to verify the issuer and the actual release artifact.
When the migration requires an isolated Mac environment for certificate import and signing verification, a remote Mac can be a practical alternative to buying hardware solely for a transition or release task. Before choosing it, confirm that the access method and environment meet the team’s own credential-handling requirements; no particular certificate custody or signing service should be assumed. KuzCloud’s remote Mac access guide describes access considerations, and the console entry point lets a team review its environment options. If the release process needs a persistent, closely controlled signing host or physical connections, a Mac the team owns may be the better fit.
Validate Your Mac App Release on Dedicated Hardware
Provision a dedicated Mac mini M4 to test your certificate migration and release workflow on real macOS hardware.
Use full root access to configure your signing, packaging, and build environment as needed.