Developer ID Certificate Expiring in 2027: 2026 Replacement Checklist

Security ·~12 min read

Developer ID Certificate Expiring in 2027: 2026 Replacement Checklist

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

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.

Explore cloud Mac plans and order