Check the certificate issuer first, then act according to what you distribute: affected .pkg installers need to be signed again with a new certificate before February 1, 2027; already signed, notarized Mac apps with a secure timestamp can continue working under Apple’s current guidance. Apple’s expiry announcement draws this distinction.
This applies to you if you independently distribute macOS apps or plugins, create .pkg installers, or publish from a continuous integration or remote Mac environment.
This week: list your Developer ID Application and Developer ID Installer certificates, inspect each issuer in Keychain Access, and mark every package release that still needs a new signature.
Last reviewed October 26, 2026. The date and handling guidance below were checked against Apple’s certificate expiry announcement, its certificate replacement instructions, and its Developer ID certificate documentation. Recheck Apple’s instructions before the deadline in case the guidance changes.
The release scenario matters more than the certificate name
Apple says the original Developer ID Certification Authority intermediate certificate expires on February 1, 2027. Certificates issued under that authority can no longer be used to sign software after that date. Apple also says that previously signed, notarized Mac software with a secure timestamp will continue to work, while a .pkg signed with an affected certificate will no longer install. These are different outcomes for different distribution artifacts.
That means one blanket “renew every certificate and rebuild everything” plan is not a safe substitute for checking your release files. A Mac app and a package installer can use different certificate types and have different consequences.
| What you distribute | Certificate to inspect | Apple’s stated impact | Priority rating |
|---|---|---|---|
| A signed and notarized Mac app with a secure timestamp | Developer ID Application | Existing software continues to work. Use a new certificate for future updates. | Plan for the next update |
A .pkg installer |
Developer ID Installer | Affected packages will not install after February 1, 2027. | Must migrate before the deadline |
| Both apps and installers | Inspect both certificate types | Changing one certificate type does not replace the other type’s role. | Track each artifact separately |
The priority labels are a release-planning assessment, not a separate Apple certification status. The key decision is whether the affected certificate signed a deliverable that users still need to install.
Identify the issuer before replacing anything
A certificate’s display name alone is not enough to establish whether it was issued under the authority covered by Apple’s announcement. Check the certificate’s issuer details, then compare them with Apple’s current replacement instructions. Apple’s guidance explains how to distinguish the original Sub-CA from G2 in Keychain Access.
How can you tell whether your Developer ID certificate came from the old authority? Open Keychain Access on the Mac that holds the certificate, locate the Developer ID identity, and inspect its certificate details and issuer. Record the result alongside the certificate type and the build or release system that uses it. If you are unsure how to interpret the issuer, do not infer the answer from a matching certificate name; verify it against Apple’s guide or your developer account.
Developer ID Application and Developer ID Installer serve different signing purposes. Apple describes Developer ID Application as the identity used to sign Mac apps distributed outside the Mac App Store. Developer ID Installer is used to sign installer packages.
| Certificate type | Typical release artifact | What to locate in your workflow |
|---|---|---|
| Developer ID Application | A Mac app or plugin distributed directly to users | The signing identity selected by your project, build script, or release automation |
| Developer ID Installer | A .pkg installer |
The identity used by the package-signing step |
| Both types | An app that is signed before being wrapped in a package | Both identities and both signing stages; one replacement does not cover the other |
Do both Developer ID Application and Developer ID Installer need replacing? Only if both are affected and used by your release process. Check each identity independently. If your app is distributed inside a .pkg, inspect the app signature and the installer signature as separate parts of the release. Replacing the app-signing identity alone does not update a package signed with an affected Developer ID Installer certificate.
Mac apps: preserve the existing release, update the next one
If a Mac app is already signed, notarized, and carries a secure timestamp, Apple’s current guidance says it will continue to work after the authority’s expiry. You do not need to treat the expiry announcement as an instruction to immediately re-sign every previously released app.
Does an already notarized, timestamped Mac app need to be re-signed after the expiry? Not solely because of this authority expiry, according to Apple’s current announcement. Keep a record of the app’s signing and notarization state. For future updates, plan to use a new certificate and follow Apple’s current signing, secure timestamp, and notarization guidance. Apple’s notarization guide describes the distribution workflow.
Do not confuse “the old app continues to work” with “the old identity can keep signing updates.” Apple’s announcement says affected certificates cannot be used for signing after the stated expiry. Therefore, schedule the certificate change before your next planned release rather than waiting until the last build is ready.
For each app, note which signing identity the project actually selects. Then check the release artifact, not just the project settings. A settings screen can show a new identity while an automated build still selects a different one through a script, keychain setting, or release configuration.
.pkg installers: schedule a replacement and re-delivery
The package case has a harder release boundary. Apple says that .pkg files signed with affected certificates will not install after February 1, 2027. The timestamp handling Apple describes for already signed Mac apps does not change that package-installation statement.
Can a .pkg signed with an affected certificate still install after the deadline? Apple says it will not install. Identify every package that users, support staff, or deployment scripts may still download. Re-sign affected packages with a new Developer ID Installer certificate, test the resulting files, and make the replacement packages available before the deadline.
Use Apple’s Mac software packaging documentation when reviewing how your app is packaged. The replacement task is not finished when a certificate appears in Keychain Access: the final package must be signed with the intended identity and successfully pass your installation checks.
A useful release inventory includes the package filename, the certificate identity used to sign it, where users obtain it, and who owns the replacement release. Include old downloads still linked from documentation or customer emails. If an installation script points to a package hosted elsewhere in your release process, update that location too. This is operational advice, not an Apple-mandated publication method; it prevents you from replacing the build while leaving an affected installer available to users.
Replace the identity without breaking the release pipeline
Step one: inventory the signing path
List the apps, plugins, and .pkg files you distribute outside the Mac App Store. For each artifact, trace the full path from source checkout to signed output. Record which certificate type is used at each signing stage and which machine or automation job has access to the identity.
Apple’s code-signing certificate technical note explains certificate relationships and code-signing behavior. Use it to understand what you are inspecting, but follow the current account help pages for the actual replacement procedure.
Step two: request the matching new certificate
In your Apple developer account, create the replacement certificate for the role you need: Developer ID Application for the app-signing stage, Developer ID Installer for the package-signing stage, or both if your release uses both. Follow Apple’s current replacement workflow. When the intermediate certificate option is offered, select G2 Sub-CA as directed by Apple’s replacement instructions.
Do not assume that choosing G2 for one certificate type automatically changes the other identity. Verify the type and issuer of every newly created certificate. If a team member performs the account step and another person maintains the build system, document the handoff so the build owner knows which identity to install and select.
Which intermediate should you select when creating the replacement? Select G2 Sub-CA when Apple presents that option, following the current replacement guide. Do not substitute an option based on a certificate’s display name or a teammate’s memory; check the issuer after installation.
Step three: install and update the signing configuration
Install the new certificate and its private key in the Mac environment that performs the release signing. Then update the actual signing selection used by your project, scripts, and automation. Check both interactive and unattended builds if your team uses both.
Keep the old identity available during a controlled transition if your release process still needs it. Do not revoke or delete a certificate simply because a replacement exists. First confirm that the new identity works in a release rehearsal and that you can recover from a failed build. Apple’s replacement guidance is the authority for account-side certificate handling; your rollback procedure should reflect your own release setup.
Step four: verify the artifact, not just the keychain
Build a test release using the new identity. Confirm the signed app or package reports the expected signing identity. For an installer, test the final .pkg produced by the release job rather than an intermediate app bundle. For an app, check the final app that will be notarized and distributed.
Keep the result of your verification with the release record: artifact name, certificate type, issuer, signing outcome, and where the tested file was obtained. This makes it possible for another release owner to confirm which identity signed the deliverable without relying on memory or a screenshot of a certificate list.
Step five: rehearse the delivery process
Run a release rehearsal through the same path you use for production. Confirm that the build job can access the signing material, chooses the intended identity, produces the correct deliverable, and places the tested output where users or downstream systems will retrieve it. If the process uses a remote Mac, verify the machine that performs the actual signing; installing a certificate on your development laptop does not update a separate build environment.
If you need a separate Mac environment for signing and release validation, review the remote Mac development environment before deciding how to run the rehearsal. Check that the access model fits your certificate-handling requirements. For questions about account use and environment operation, the VPSPush help center is the appropriate place to confirm service details.
A release checklist you can complete this week
- [ ] List every macOS app, plugin, and
.pkgyou distribute outside the Mac App Store. - [ ] Identify whether each artifact uses Developer ID Application, Developer ID Installer, or both.
- [ ] Inspect each certificate’s issuer in Keychain Access and compare it with Apple’s current replacement guidance.
- [ ] Mark affected
.pkgfiles for re-signing and replacement before February 1, 2027. - [ ] For existing apps, record whether they are signed, notarized, and include a secure timestamp; do not schedule an unnecessary rebuild based only on the authority expiry.
- [ ] Create the matching replacement certificate and select G2 Sub-CA if Apple presents that option.
- [ ] Update the signing identity in the project, scripts, and release automation that actually produce your deliverables.
- [ ] Test the final app and final
.pkgseparately where both are distributed. - [ ] Rehearse the release and confirm the replacement artifact reaches the same delivery locations as the old one.
- [ ] Keep a rollback path until the new signing and delivery process has passed your release checks.
Choose the migration effort by artifact and exposure
| Release condition | Recommended action | Completion signal |
|---|---|---|
| Only existing timestamped, notarized Mac apps use the affected Application certificate | Preserve the current release; move the new identity into the next update cycle | A planned future build signs with the replacement identity |
Users still need .pkg files signed by the affected Installer certificate |
Re-sign, test, and replace those packages before the stated deadline | The tested replacement package is the one users can download |
| Your pipeline produces both apps and packages | Verify both identity types and each final artifact | The release rehearsal confirms the app and package use their intended identities |
| You cannot identify the signing identity used by automation | Pause certificate cleanup; trace the build configuration before changing keychain contents | The release owner can identify the selected identity and issuer |
The highest-risk failure is not necessarily a failed signing command. It can be an old installer that remains available after the replacement has been built, or an automated release job that silently continues using the old identity. Treat the certificate inventory, build configuration, and delivery location as one migration rather than unrelated cleanup tasks.
Keep the Mac environment decision separate from the certificate decision
A local Mac is usually simpler if you already own suitable hardware, control it directly, and run releases only occasionally. It also avoids transferring signing material into a remote environment. But a dedicated local release machine ties the workflow to that hardware, requires you to maintain its availability, and may be an unnecessary purchase if you only need a short migration and verification window.
A remote Mac can provide an isolated environment for a release rehearsal without buying another Mac. It also adds operational checks: confirm who can access the machine, how signing material is installed and removed, and whether your release process can retrieve the resulting artifacts reliably. Renting is not the best answer for every team; a long-running production build system with strict hardware requirements may justify a dedicated machine you manage yourself.
The practical decision is to resolve the certificate scope first. If you have no affected package, no upcoming update, and a verified app with a secure timestamp, there may be no reason to re-sign that existing app solely for this expiry. If affected .pkg installers or an imminent update are in scope, schedule a test release now and leave time to replace the actual deliverables.
If your current setup means buying a Mac just to perform a one-off signing migration, or relying on a developer’s personal machine with unclear availability, a short-term remote Mac can be a more controlled option for the build and delivery rehearsal. It is less suitable when you require permanent, tightly controlled physical hardware or a stable long-term workload that makes ownership more economical. Compare access and operating requirements first; if a temporary Mac environment fits, review VPSPush remote Mac plans for the available options.
Further reading
Verify Your Next macOS Release on a Dedicated Mac
Rent a dedicated VPSPush Mac mini M4 to test your signing and installer workflow in a physical macOS environment.
