Automating Mac App Store License Assignments and Reclamation

Automating Mac App Store License Assignments and Reclamation

Final Cut Pro request workflow: Self Service creates an entitlement marker, Recon and an Extension Attribute add the Mac to a license Smart Group, and Jamf Pro installs the device-assigned app with progress notifications.
For IT teams, a paid Mac App Store title is not simply another package to deploy. A limited Apps and Books license pool must be assigned only when a Mac needs it, communicated clearly while Apple’s managed delivery works in the background, and reclaimed when a shared, lab, or checkout Mac moves to its next user. This article documents a practical Jamf Pro design for doing that without API credentials on endpoints, unsupported repackaging, or a permanent all-apps image. Read through it if you need an implementation that is repeatable for one title today and extensible to a small catalog tomorrow.

Executive summary

  • Paid Mac App Store titles consume a finite Apps and Books license pool. This workflow assigns a license only after a Mac requests the title and reclaims it when the app is removed.
  • A root-owned local marker, reported through an Extension Attribute (EA), places the Mac in a per-app Smart Group. That group is the Mac App’s only inclusion scope.
  • The design keeps Jamf Pro API credentials off endpoints. Its trade-off is one small EA and Smart Group for each licensed title.
  • Inventory submission is required: until Recon completes, Jamf Pro cannot see a marker change or update the Mac’s entitlement scope.

Quick-start configuration

Use one matching set of objects for each managed title. The detailed configuration and safety checks appear later in this article.

Component Required purpose or setting
Extension Attribute (EA) Checks /Library/Management/mac_app_group_membership/<APP_KEY>_license.request and returns Yes only for a safely owned marker.
Smart Group Has one entitlement criterion: the matching EA is Yes.
Mac App record Uses an Apps and Books, device-assigned title; its only inclusion scope is that Smart Group; Install Automatically is enabled.
Self Service request policy Runs jamf_self_service_mac_app_group_membership_request.sh as root with $4=add and $5=<APP_KEY>.
Reclaim policy Removes the approved app bundle first, then runs the same script as root with $4=remove and $5=<APP_KEY>.

⚠️ Prerequisite: Recon must work. This design is inventory-driven. On macOS 27.0.1 Macs affected by PI-1725, disabling Include home directory sizes was a successful workaround in our October 8, 2026, test with Jamf Pro 11.32.0-t1787580540993. It is not a universal diagnosis; confirm the detailed Recon guidance against your own fleet and Jamf support case.

The environment: why this workflow exists

Architecture at a glance

  • A user requests an app in Self Service. The policy creates one small, root-owned marker for that app on that Mac.
  • Recon reports the marker through an Extension Attribute. A Smart Group then puts only that Mac in scope for the device-assigned Apps and Books app.
  • Jamf Pro assigns a license and delivers the app asynchronously. The request policy keeps the user informed with progress notifications while delivery is pending.
  • To reclaim the license, remove the approved app bundle and the same marker. After the next Recon, the EA returns No, the Mac leaves scope, and the license can be reused.

The marker is the only entitlement state stored on the Mac. This avoids placing Jamf Pro API credentials on endpoints, manual IT scoping, requiring membership in a directory-services group such as a course roster, or rewriting Mac App scope for every request.

Campus context: one campus is not one standard Mac

This workflow was built at the J. Willard Marriott Library at the University of Utah, where the managed Mac environment spans thousands of endpoints across public computing labs, faculty and staff workstations, specialized media production spaces, administrative offices, and a large student laptop checkout pool. The Library’s checkout fleet is returned and reissued on a much shorter, less predictable cycle than a conventional one-user device, so every installed title affects restore time, available disk space, update workload, and the next student’s experience. For related background, see MacBook Imaging at Scale: Restore, Verify, and Checkout and Managing Jamf Title Editor at Scale.

The University of Utah is decentralized, and that variety is reflected in the software request queue. A general-purpose Mac may need only a small baseline, while a course, department, research group, accessibility need, or media production workflow can require something much more specialized. Across more than 250 software needs, installing every Mac App Store title on every managed Mac would consume storage, create unnecessary update and support work, and tie up a limited pool of paid licenses on computers that may never use the app. The Library’s popular student laptop checkout program has a maximum 60-day checkout period, so its Macs must serve a wide range of campus needs without becoming a single, oversized software image that slows preparation and return to service.

Adding a Mac App in Jamf Pro is straightforward: select the app, choose a scope, and enable Install Automatically. That model becomes harder to operate when each assignment consumes a finite license and a Mac needs the app only after someone requests it.

This workflow separates the per-Mac entitlement from the Mac App configuration. In Self Service, a person requests the app. The request marks that Mac as entitled, Jamf Pro assigns its device-based Apps and Books license and delivers the app asynchronously, and the user receives progress updates. Later, a reclaim policy can uninstall the app when appropriate and remove that Mac’s entitlement, releasing the license for another device.

The Mac App configuration stays stable throughout. The entitlement is small, local, and auditable, so the workflow does not need Jamf Pro API credentials, a static-group API worker, or a script that rewrites a Mac App’s scope.

Why repackaging an App Store app stopped being an answer

The implementation begins in The design: a local trigger file drives a Smart Group. This section explains why the supported managed-distribution path replaced our earlier repackaging approach.

Before managed distribution became our standard, it was tempting to repackage a Mac App Store app—or simply copy its bundle into /Applications—and manage it like a conventional package. The copy could look successful: the app launched and its files were present. An older app version might also avoid a receipt check in the part of the app a user happened to use. None of that proves that the destination Mac has a valid App Store entitlement or that the installation is supported.

The appeal was practical. A locally cached package can offer controlled versioning, faster policy-based installation, and pre- or post-install customization without depending on an App Store download at delivery time. Those operational benefits do not change the licensing boundary: copying the app files cannot create, transfer, or maintain the App Store entitlement that managed distribution provides.

Historically, repackaging appeared to work for nearly all free App Store titles we tested. The free Mac App Store edition of DaVinci Resolve was a notable exception: it exposed App Store-style credential prompts that made the limitation clear earlier. That local success was never proof of redistribution rights, a valid entitlement on the destination Mac, or future compatibility. A locally available package can avoid a download at install time; it cannot create, transfer, or repair an App Store entitlement.

Mac App Store apps can contain an App Store receipt inside the application bundle. Apple documents receipt validation as part of the StoreKit/App Store model: an app can examine receipt attributes such as its identity and version, and can validate a receipt with the App Store. A repackaged app may bring along an old receipt file, but repackaging or copying that file does not create a purchase, device-based assignment, or fresh managed installation for the destination Mac. Whether the app accepts that copied state is an implementation detail of that app version and can change with an update. Apple: App Store receipts Apple: validating receipts with the App Store

This explains why repackaging sometimes appeared successful in the past and then failed later. If a prior app version did not validate its receipt at launch or did not reach a feature that required validation, a repackaged app could remain usable. A newer release can validate more consistently, require a receipt that matches its expectations, or rely on the current App Store and Apple Account/Media Services state. Administrators should therefore treat a repackaged App Store app—including a direct bundle copy—as unsupported even if it happens to launch in a test; it can fail after an app update, a macOS update, a network/account change, or a newly exercised licensing check.

For legacy on-device receipt validation, Apple describes a sequence in which the app loads the receipt from its bundle; verifies the receipt signature’s chain of trust to Apple; compares the receipt’s bundle identifier and version to the app; and validates a device-specific SHA-1 hash in the receipt. An app developer chooses whether and how to perform those checks, so administrators cannot infer an individual title’s validation behavior from the presence of _MASReceipt alone. Modern StoreKit can instead validate an App Store-signed AppTransaction, which is another reason not to assume that repackaging a legacy receipt predicts the behavior of a current release. Apple: validating receipts on the device Apple: AppTransaction

Legacy receipt validation can also produce hardware-repair edge cases. On macOS, Apple’s legacy model includes a device-specific hash derived from a network-interface MAC address. A developer has documented a case in which a logic-board replacement changed the relevant interface naming and caused receipt validation to fail until the app’s validation code was updated to consider all built-in Ethernet interfaces. This is an app-specific developer report, not evidence of Logic Pro or Final Cut Pro behavior. For IT, the practical lesson is to troubleshoot a post-repair entitlement failure through a supported App Store or managed-app reinstall—not by repackaging the app or copying a receipt. Lapcat Software: Mac App Store receipt validation revisited

Apple Creator Studio requires a separate operational model. Apple distributes the Creator Studio versions of Final Cut Pro, Logic Pro, Motion, Compressor, MainStage, and Pixelmator Pro through a subscription. They are distinct from the one-time-purchase Mac apps and can coexist on the same Mac. Creator Studio subscription access does not consume the finite device-assigned Apps and Books license pool used by this workflow; subscription entitlement must be managed separately. Apple states that an active subscription is required to open or edit Creator Studio projects, but does not publish each app’s internal runtime-validation implementation. Accordingly, the lower path in the diagram represents subscription access, not a claim that Creator Studio uses a particular receipt format or API. For institutional deployment, the key boundary is that volume licenses remain available for the one-time-purchase versions, not the Creator Studio subscription editions. Apple Creator Studio: subscription and volume-licensing information Apple: identify Creator Studio and one-time-purchase apps

Comparison of legacy Mac App Store receipt validation and Apple Creator Studio subscription access.

The following Logic Pro dialog is an example from a repackaging test. It is a useful, user-visible symptom: the app could not find a valid App Store purchase and directed the user to delete that copy and obtain Logic Pro from the App Store. The dialog does not, by itself, identify which receipt or account-validation check failed. It does demonstrate why a successful file copy is not evidence of a valid, managed App Store installation.

Logic Pro alert stating that a valid App Store purchase could not be found.

Observed Logic Pro receipt/purchase validation failure after a repackaging test. The supported remediation is managed App Store distribution, not modifying or bypassing the receipt check.

Local tests and community reports are useful warning signs, but they do not establish a supported deployment method. For current Logic Pro releases, deploy the device-assigned Apps and Books app through Jamf Pro. Plan a deliberate migration away from legacy repackaging in labs and classrooms.

Apple does not publish Logic Pro’s internal entitlement-validation implementation, so this evidence does not prove a particular StoreKit API, behavior for every Logic Pro 11.x build, or a specific cause for the failure. Apple completed its receipt-signing transition from SHA-1 to SHA-256 on January 24, 2025; it affects incompatible local receipt validation, not AppTransaction or Transaction validation. Apple: TN3138, receipt signing certificate changes A repackaged App Store app remains unsupported, even if a particular test or older version appears to work.

For investigation—not as a deployment workaround—MAS Receipt Checker can show the receipt properties that are present in a Mac App Store app and help explain receipt validation errors. Its author notes that it is primarily a developer tool and that validation failures can surface as the app exits with code 173 on recent macOS versions. It is useful evidence when troubleshooting, but it cannot make a repackaged receipt valid or assign a license.

The Apple Creator Studio transition made this distinction impossible to ignore in our environment. Apple now offers subscription versions of Final Cut Pro, Logic Pro, Motion, Compressor, MainStage, and other creative apps, while the one-time-purchase Mac versions remain available for assignment through Apple School Manager, Apple Business (previously known as Apple Business Manager), and device management. Apple explicitly states that IT teams can assign the one-time-purchase versions to Mac computers. Apple’s deployment guidance

When we tested repackaged current Apple Creator Studio apps, including direct bundle copies, every version we tested reached a MAS receipt and Apple Account/Media Services blocker: the app could not establish a valid App Store purchase on the destination Mac. Repackaging can preserve the application files—and may preserve an old receipt—but it cannot make that receipt represent a new purchase, device-assigned managed license, or valid destination-Mac entitlement. The observed error does not identify the app’s exact internal validation check, but it is enough to make repackaging unreliable. The answer is not to find a cleverer bypass for the receipt check; assign the title through device management and let Apple’s managed distribution deliver it.

This also matters because the two product families can coexist. Apple notes that Creator Studio and one-time-purchase versions of these pro apps can both be installed on a Mac and uses distinct icons to help identify them. Apple: identify Creator Studio apps Before automating an install or removal, confirm which app record, bundle, and license model the policy is targeting.

The design: a local trigger file drives a Smart Group

Each managed title receives its own local trigger file (called an entitlement marker in the scripts), Extension Attribute (EA), and License Scope Smart Group. The trigger file is the changing state; the Mac App configuration remains stable.

Six-step workflow from a Self Service request to marker creation, Recon, Smart Group inclusion, license assignment, and app installation.

For Logic Pro, the marker is:

/Library/Management/mac_app_group_membership/logic_pro_license.request

The directory is owned by root:wheel with mode 755; individual markers are root:wheel with mode 600. The EA returns Yes only when those ownership and mode checks succeed. That prevents an unprivileged user from creating an entitlement by dropping a file in a writable directory.

The inverse flow is just as important:

Removing the Mac from scope allows Jamf Pro to revoke the managed assignment and return the license to the available pool; it does not remove an App Store application bundle. The uninstall step must occur before marker removal when the Mac should no longer retain the application.

Six-step license-reclamation workflow from app removal to marker removal, Recon, Smart Group exit, and license reclamation.

Prerequisite and troubleshooting: Recon must complete (PI-1725)

⚠️ Inventory is a hard dependency. On affected macOS 27.0.1 Macs, PI-1725 can prevent Recon from completing, so marker changes never reach the EA or Smart Group. Test the workaround below against your own fleet and Jamf support case before treating it as the cause of every stalled request.

This design depends on a completed jamf recon. Until inventory is submitted, the marker change cannot reach the Extension Attribute, the Mac cannot enter or leave the License Scope Smart Group, and Jamf Pro cannot reliably assign or reclaim the managed App Store license.

In testing on October 8, 2026, with macOS 27.0.1 and Jamf Pro version 11.32.0-t1787580540993, Jamf Pro issue PI-1725 was associated with inventory collection stalling when Include home directory sizes was enabled. On affected Macs, jamf recon stalled at Locating hardware information (macOS 27.0.1) and did not submit the inventory update. Our testing, including validation with multiple affected Macs, found that disabling the option allowed Recon to complete again. Similar macOS 27 reports from Jamf administrators describe the same workaround. Jamf Pro inventory collection settings Jamf Nation macOS 27 Recon discussion. This is local and community evidence of a mitigation, not a publicly documented Jamf root-cause analysis; validate it against your own support case and fleet.

As a temporary workaround, we disabled Include home directory sizes in Settings > Computer Management > Inventory Collection and tested inventory collection on an affected Mac. After the change, jamf recon completed successfully. The tradeoff is that Jamf will no longer report the size of each individual user’s home folder; normal storage and free-disk-space inventory continue to be collected.

Jamf Pro Inventory Collection settings with Include home directory sizes disabled.

Temporary PI-1725 workaround: disable Include home directory sizes while leaving local-account collection enabled.

Before relying on an entitlement request, test a manual sudo /usr/local/bin/jamf recon on an affected Mac and confirm that its inventory timestamp advances.

Leave this option disabled until Jamf confirms a fix for PI-1725 in a Jamf Pro release that you have tested in your environment. If Recon continues to stall after the setting is disabled, do not assume this issue is the only cause: audit Extension Attributes—especially any that invoke du or scan broad file paths—because they can independently make inventory collection slow or hang.

Script availability

The request-policy script and per-app Extension Attribute (EA) template described in this article are posted in the Marriott Library Apple Infrastructure team’s GitHub repository. The repository includes the request/reclaim script, the EA template, and configuration guidance for the matching Jamf Pro policies. Review the accompanying documentation before use, test in a non-production Jamf Pro site, and adapt policy names, scope, and support language for your environment.

The two companion scripts

File Purpose
jamf_self_service_mac_app_group_membership_request.sh Creates or removes a root-owned entitlement marker, runs Recon, provides optional user status notifications, and records timing.
mac_app_license_marker.sh A per-app EA template that safely reports Yes or No from the matching marker.

The request script is used for both grant and reclaim policies. It validates the app key, uses a per-app lock, creates markers atomically, and can monitor the expected application path after an add request. It does not call the Jamf Pro API or contain API credentials.

The EA is copied once per title. Set APP_KEY in each copy, then use the same value as a policy parameter $5. For example:

# Logic Pro EA
APP_KEY="logic_pro"

# Final Cut Pro EA
APP_KEY="final_cut_pro"

The security-relevant EA decision is intentionally small: it validates the root-owned parent directory, rejects symlinks, and grants scope only for the expected root-owned, mode-600 marker.

if [[ ! -d "$MARKER_DIRECTORY" || -L "$MARKER_DIRECTORY" ]]; then
    echo '<result>No</result>'
    exit 0
fi
directoryOwner=$(/usr/bin/stat -f '%Su:%Sg' "$MARKER_DIRECTORY")
directoryMode=$(/usr/bin/stat -f '%Lp' "$MARKER_DIRECTORY")
if [[ "$directoryOwner" != 'root:wheel' || "$directoryMode" != '755' ]]; then
    echo '<result>error:unsafe-marker-directory</result>'
    exit 0
fi
if [[ -f "$MARKER_FILE" && ! -L "$MARKER_FILE" ]]; then
    markerOwner=$(/usr/bin/stat -f '%Su:%Sg' "$MARKER_FILE")
    markerMode=$(/usr/bin/stat -f '%Lp' "$MARKER_FILE")
    if [[ "$markerOwner" == 'root:wheel' && "$markerMode" == '600' ]]; then
        echo '<result>Yes</result>'
        exit 0
    fi
fi
echo '<result>No</result>'

Threat model: this protects against accidental marker changes and unprivileged users attempting to create an entitlement. A local administrator or any process already running as root can alter local state, including this marker. Treat Jamf Pro’s Apps and Books license pool, policy scope, inventory, and administrative controls as the real backstops; do not treat the marker as tamper-proof against an administrator.

Scale and architecture trade-off

This design intentionally trades Jamf Pro object count for a credential-free, inventory-driven workflow: each title needs its own small Extension Attribute (EA) and License Scope Smart Group. That is a good fit for a modest set of licensed titles when the EA is deliberately cheap—the template only checks a known local marker’s ownership and mode. Jamf runs script-based EAs whenever a computer submits inventory, and notes that EAs can add time and network traffic to inventory collection. Jamf: Extension Attribute input types

Before expanding this pattern to a large catalog, audit the existing EA and Smart Group estate. Smart Group membership is updated when computers submit inventory, and Jamf specifically cautions that excessive Smart Group nesting can degrade server performance. Keep these License Scope groups flat, give each one a single EA criterion, and retire objects that are no longer needed. Jamf: Smart Groups

An alternative architecture can use a policy script and the Jamf Pro API to add or remove computers from per-app static groups. That can reduce the number of EAs and dynamic Smart Groups, but it introduces a different security and operational responsibility: the client needs authority to alter group membership. Do not put API client secrets, passwords, or bearer tokens in Jamf policy parameters or command-line arguments. Arguments can be exposed through process inspection or logging to sufficiently privileged local processes while a script runs. If an API-based design is required, use narrowly scoped, rotatable credentials and a root-readable secret-storage mechanism; treat its credential handling and audit trail as a separate security review. This article uses the marker/EA design precisely so that no API credential is stored on or passed to the Mac.

Design Marker / EA / Smart Group (this article) API / static group
Endpoint credential None. A client must be able to authenticate to Jamf Pro.
Jamf objects One EA and Smart Group per title. Fewer dynamic objects; static groups per title.
State change Reconciled inventory updates group membership. The endpoint changes group membership through the API.
Audit trail Marker state, inventory, Smart Group membership, and policy history. API activity, static-group membership, and policy history.
Primary risk Object count and inventory-evaluation overhead at scale. Credential storage, rotation, scope, and endpoint exposure.

 

Apps and Books (formerly VPP) versus the Mac App Store

“VPP” is common shorthand for Apple’s former Volume Purchase Program. Apple’s current name for organizational app licensing is Apps and Books in Apple School Manager or Apple Business Manager. It uses the same App Store catalog, but the IT ownership and management model is fundamentally different from an app that a person obtains with a personal Apple Account in the Mac App Store.

Topic Personal Mac App Store acquisition Apps and Books device assignment (this workflow)
License owner The individual Apple Account holder. The organization purchases or obtains the license through Apple School Manager or Apple Business Manager.
Apple Account on the Mac Required for the user to obtain the app. Not required for device assignment.
IT deployment The user installs the app; it is outside this entitlement workflow. Jamf Pro assigns a device-based license, then sends the managed installation.
Reclaiming a finite license Removing a local app bundle does not return a personal purchase to an organizational pool. Removing the device from the managed scope can revoke and reassign the organization’s license.
Updates The user controls normal App Store updates for their copy. Device-assigned managed-app updates are initiated by the device-management service.

Apple states that Apps and Books support device and user assignment, that device assignment does not require an Apple Account for app access, and that the organization retains ownership when managed licenses are revoked or reassigned. Apple: distribute content with Apps and Books. Apple also documents that device-assigned managed-app updates are initiated by the device-management service. Apple: distribute managed apps. This article uses device assignment because it supports shared labs, checkout Macs, and other multi-user devices without binding the license to a person’s account. In Jamf Pro, make sure the Mac App record uses the Apps and Books content token and device-based assignment; a personal App Store installation cannot participate in the marker, Smart Group, and license- reclamation loop.

Jamf Pro configuration

For every App Store title managed this way, create a matching set of objects:

  1. A device-assigned Mac App record using the one-time-purchase Apps and Books title (formerly called VPP).
  2. A dedicated EA copy with that title’s APP_KEY.
  3. A dedicated Smart Group whose only entitlement criterion is that EA is Yes.
  4. A Mac App scope that uses that Smart Group as its sole inclusion scope and is configured to Install Automatically.
  5. An add/reinstall Self Service policy and a separate uninstall/reclaim policy.

 

Jamf Self Service policy and Extension Attribute configured with the same logic_pro app key.

The policy passes add and logic_pro; the Extension Attribute uses APP_KEY="logic_pro". Use the same filename-safe key in every matching policy and EA copy. The Smart Group then evaluates that EA’s Yes result, and the Mac App record is scoped only to that Smart Group.

The sole-scope rule matters. A Mac that is included manually or through a second Smart Group remains in overall scope after its marker is removed, so the workflow can no longer guarantee license reclamation.

Request governance for scarce titles

Self Service is not required to be first-come, first-served. Scope each add policy to the population that may request the title—for example, a department, course, device class, or approved requester group. For especially scarce or high-cost titles, place an approval or service-request step before the policy runs. This workflow automates entitlement delivery after a request is authorized; it does not replace a decision about who is eligible to consume a finite license.

Add or reinstall policy parameters

Run the request script as root.

Parameter Logic Pro Final Cut Pro Meaning
$4 add add Create the entitlement marker.
$5 logic_pro final_cut_pro Must match the corresponding EA APP_KEY.
$6 false false Make the change; set true only for a dry run.
$7 /Applications/Logic Pro.app /Applications/Final Cut Pro.app Optional bundle path to monitor.
$8 3600 3600 Overall request deadline, in seconds.
$9 false false Enable root-only diagnostic logging when needed.

For an add request whose $7 application path is not already present, the policy can immediately confirm that the request was accepted, provide a status update every five minutes, and detect when the app bundle appears. That does not make Apps and Books delivery synchronous. It communicates the real state: the Mac is entitled and Jamf Pro is still processing the managed installation.

User notifications: make the asynchronous workflow understandable

Mac App Store delivery is asynchronous, and that distinction matters to the person who selected Install in Self Service. Without feedback, a user can reasonably assume that nothing happened while the marker, inventory update, Smart Group evaluation, license assignment, and app-delivery command are working through Jamf Pro. They may submit duplicate requests, contact support, or restart the Mac at the least helpful point in the process.

For add requests with a parameter $7 set to the expected application path, the request script sends user-facing notifications immediately, every five minutes while the request is still active, when the app bundle is found, or when the overall deadline is reached. Notifications are deliberately tied to observable workflow stages rather than promising an instant installation. The supplied script uses Jamf’s Management Action app when available, then falls back to a user-context osascript notification. It does not require swiftDialog or jamfHelper.

Logic Pro notifications from request submission through processing, installation, or a pending deadline.

A notification should tell the user what the workflow has actually reached, not merely that a policy ran.

Notification Corresponding workflow stage What it means to the user
<App> Request Started The add policy has accepted the request and is creating the per-app marker. The request was received; this is not yet a license assignment or completed install.
<App> Request Update The script is still waiting after the request. Recon may be running, or Jamf Pro may still be evaluating scope or delivering the app. The request is still active. The script repeats this update every five minutes while it waits.
<App> Installation Processing Recon completed and the marker state was submitted. Jamf Pro can now evaluate scope and begin managed-app delivery. The app may take additional time to appear. This notification does not confirm Smart Group membership, license assignment, or delivery completion.
<App> Installed The expected app path exists after the request. The app bundle was detected and the user can try the app. For a true first-install verification, test on a Mac where that bundle was not already present.
<App> Installation Pending The configured overall deadline ended before the expected app path appeared. The request may still be queued, but support should review the Mac App Store Apps status and Management History.

The default notification cadence is five minutes. Keep the tone concise and truthful: “request received,” “still processing,” “installation processing,” “complete,” or “pending.” Do not say that the app is installed merely because the marker was created or the EA returned Yes. Those events establish entitlement and scope; they do not prove that the app-delivery command has finished.

When no Apps and Books license is available

If requests exceed the available device-assigned Apps and Books licenses, the marker, EA result, and Smart Group membership can all be correct while app delivery remains pending or does not complete. The request script eventually reports Installation Pending when its deadline expires; it does not claim that a license was assigned. Support should check the title’s available license count, the Mac App status, and Management History before retrying. Avoid repeatedly changing the marker or adding alternate scopes to force an install, because that obscures the entitlement state and can defeat reclamation. Test and document the observed license-release and re-assignment timing in your own Apple School Manager or Apple Business Manager tenant; do not promise users a fixed availability time.

Uninstall and reclaim policy parameters

The reclaim policy must perform these actions in order:

  1. Warn the user and close or uninstall the intended app bundle.
  2. Remove only the approved, app-specific external locations that this deployment previously installed. Keep an explicit, reviewed per-app path list; do not use broad name-based globs or remove user-created content.
  3. Run the same request script as root with $4=remove and the title’s $5 app key.
  4. Leave $7 blank; use $8=1800 unless the environment needs a longer Recon deadline.

For Logic Pro, the removal call uses remove and logic_pro; for Final Cut Pro, it uses remove and final_cut_pro. Recon then updates the EA to No and the Mac exits the relevant License Scope Smart Group.

Reclaim triggers, stale holders, and wipe behavior

Choose and document the event that runs the reclaim policy. In a checkout program, that is commonly the return, restore, or reissue workflow; in a lab, it may be a scheduled reset or an administrator-approved removal. Do not claim automatic inactivity or age-based reclamation unless it is actually deployed, tested, and communicated to users.

A Mac that stops checking in can retain a Yes EA result and continue to hold a license. Periodically review each title’s Smart Group against inventory recency, then investigate lost, retired, or stale Macs through the normal asset-management process. This can be an administrator-side report or review; it does not require putting API credentials on endpoints. Compare the number of current Smart Group members with the available Apps and Books licenses to identify a shrinking pool before requests begin to queue.

A wipe removes the local marker, but it does not by itself guarantee that Jamf Pro has received a final inventory update or revoked the managed assignment. Before erasing, run the reclaim workflow when possible. After a wipe or re-enrollment, review the old computer record and its managed-app assignment, then remove or retire stale management records according to your institution’s device-lifecycle process.

Uninstalling safely in the Creator Studio era

⚠️ Protect shared and user-created data. A license reclaim is not authorization to erase all creative-app content. Never use broad deletions such as rm -rf /Library/Audio/*, /Library/Application Support/*, or name-based wildcards. Remove only the exact application bundle and a separately reviewed list of deployment-owned paths.

Reclaim decision guide

Category Examples Default action
Safe to remove during reclaim The approved app bundle, such as /Applications/Logic Pro.app, and its entitlement marker at /Library/Management/mac_app_group_membership/<APP_KEY>_license.request Remove the bundle first, then remove the marker and run Recon.
Preserve by default .fcpbundle libraries, ~/Movies/Motion Templates, ~/Movies/Final Cut Pro Backups, and ~/Music/Audio Music Apps/ Leave user and project data in place unless a separately approved data-removal process covers it.
Evaluate before removal /Library/Audio/Apple Loops/Apple/, /Library/Audio/Impulse Responses/Apple/, plug-ins, and system-level content Remove only exact, deployment-owned paths after confirming they are not shared by another approved app or workflow.

Uninstalling a managed Mac App and reclaiming its license are related, but they are not the same operation. Treat them separately.

First, identify the exact app family on the Mac. Do not assume that a Creator Studio-era app and a one-time-purchase app are interchangeable just because they share a product name. Apple documents that both versions can coexist, so the Jamf Mac App record, policy bundle path, and uninstall target must all refer to the same variant.

For the one-time-purchase versions used by this workflow, the current bundle paths are commonly:

/Applications/Logic Pro.app
/Applications/Final Cut Pro.app

Verify paths and bundle identifiers on a representative Mac before publishing an uninstall policy. Do not use a broad recursive delete against /Applications or a name-based wildcard that could remove the Creator Studio version as well.

If the deployment also installed app-specific helper components, plug-ins, or content in external system locations, record those exact paths in a reviewed per-app removal list. The reclaim policy may remove only entries from that list, and only when it can establish that the managed deployment installed them. This gives technicians a way to clean up approved deployment artifacts without treating an app uninstall as permission to delete all similarly named files on the Mac.

Second, decide what happens to user-created work and downloaded content. Apple advises backing up Final Cut Pro libraries before removal. Apple’s Pro App removal guidance An app-bundle uninstall policy should normally leave libraries, projects, presets, and user media alone unless there is a separately approved data-removal requirement.

Final Cut Pro deserves an additional safeguard: a library is not confined to one predictable folder. Its media, cache files, Motion content, and backups can be stored inside the .fcpbundle or in locations selected for that library. By default, Final Cut Pro stores library backups in ~/Movies/Final Cut Pro Backups, but an editor can choose another location. Apple: set Final Cut Pro library storage locations Apple: restore a Final Cut Pro library Do not try to find and delete every .fcpbundle, cache, or backup as part of a license reclaim: those locations can contain active user work and media.

The same caution applies to templates and plug-ins. Custom Motion templates normally live in ~/Movies/Motion Templates, or can be consolidated into a library; they are user or project content, not Final Cut Pro’s application bundle. Apple: manage Motion content in Final Cut Pro Third-party FxPlug content is not managed inside a Final Cut Pro library, and Apple directs administrators to use the plug-in vendor’s removal procedure where available. Do not delete /Library/Plug-Ins/FxPlug wholesale: it can contain plug-ins used by other applications. Apple: Final Cut Pro and Motion plug-in compatibility

If a deployment deliberately installed Final Cut Pro sound effects, its documented system location is /Library/Audio/Apple Loops/Apple/Final Cut Pro Sound Effects/. Include that path in a removal list only when the deployment can establish that it installed the content and that no other approved workflow needs it. Apple: access external audio files in Final Cut Pro

Motion and Compressor need the same separation between application removal and content lifecycle. Motion saves custom library objects under ~/Library/Application Support/Motion/Library, project presets under ~/Library/Application Support/Motion/Presets, and Final Cut templates under ~/Movies/Motion Templates. Those are user-created assets that can be needed by Final Cut Pro projects, so do not remove them as part of a Motion license reclaim. Apple: move Motion assets to another computer

Compressor custom settings are similarly user state, commonly stored in ~/Library/Application Support/Compressor/Settings; current Final Cut Pro and Motion documentation also identifies a Pro Apps group-container location for shared Compressor settings. Preserve or export custom settings before a reset or removal. Apple describes deleting a user’s Compressor support folder and preferences as a troubleshooting reset, not a routine uninstall action; its Apple Qmaster cleanup applies only to specific legacy Compressor releases. Apple: resolve an issue in Compressor Apple: Compressor presets in Final Cut Pro

Logic Pro and Final Cut Pro location review before removal

The table below is an inventory checklist, not a blanket deletion list. It identifies locations to review when designing a separately approved full-removal workflow. The license-reclaim policy in this article removes the managed app bundle and its marker; it does not remove the locations below by default.

App Location or class of data to review Default treatment
Logic Pro /Applications/Logic Pro.app Remove only when the approved policy is intended to uninstall this exact app variant.
Logic Pro /Library/Audio/Apple Loops/Apple/ and /Library/Audio/Impulse Responses/Apple/ Apple Sound Library content. These system locations can be shared with other Apple creative apps; inventory the exact subpaths before considering removal.
Logic Pro /Library/Application Support/Logic/ Logic Pro Sound Library components and plug-in settings. Inventory the exact subpaths and account for Sound Library relocation before considering removal.
Logic Pro 12+ /Users/Shared/Logic Pro Library.bundle, ~/Music/Logic Pro Content.bundle, and ~/Music/Audio Music Apps/ Modern deployed content and per-user library state. Preserve by default; test any content cleanup separately from license reclamation.
Logic Pro ~/Library/Application Support/Logic/ May contain user-created impulse responses and plug-in settings. Preserve unless a data-removal requirement explicitly covers it.
Final Cut Pro /Applications/Final Cut Pro.app Remove only when the approved policy is intended to uninstall this exact app variant.
Final Cut Pro .fcpbundle libraries and their configured media, cache, Motion-content, and backup locations User or project data that can live inside the library, elsewhere on the startup volume, or on external storage. Never enumerate and delete these broadly.
Final Cut Pro ~/Movies/Final Cut Pro Backups, ~/Movies/Motion Templates, and third-party FxPlug locations Backups, custom templates, and plug-ins. Preserve by default; use a vendor-specific or separately approved removal process when required.

Apple documents Logic Pro Sound Library components in several system locations, including Apple Loops, impulse responses, sampler instruments, samples, and plug-in settings. It also allows Sound Library relocation, so a path list cannot prove that all content is local or safe to remove. Apple: manage Logic Pro content For Logic Pro 12+ content, Loopdown documents the shared bundle and per-user database paths above; treat them as version-specific implementation details and validate them in your own test environment.

Before approving a full cleanup, test the exact macOS and app versions on representative single-user, shared-lab, and multi-user Macs. Confirm what the deployment installed, whether GarageBand, MainStage, Motion, Final Cut Pro, or third-party plug-ins share the candidate paths, and whether any library or media lives on attached storage. Test in a non-production group first, record the exact approved paths, preserve a recoverable backup where appropriate, and verify that the remaining apps and user projects still work. Do not use broad recursive deletion of /Library/Audio, /Library/Application Support, or /Library/Audio/Plug-Ins/Components to implement a Logic Pro or Final Cut Pro uninstaller.

Logic Pro’s current content model deserves special attention. The Loopdown project documents that Logic Pro 12+ content no longer follows the traditional all-pkg deployment model. Content can live in locations such as:

~/Music/Logic Pro Content.bundle
/Users/Shared/Logic Pro Library.bundle
~/Music/Audio Music Apps

Those locations are content and per-user state, not the Logic Pro application bundle. They should not be deleted merely because the license marker is being removed. Loopdown also notes that the per-user ~/Music/Audio Music Apps database may affect how newly deployed sound-library content is recognized. That is a content-lifecycle decision to document and test independently of App Store license reclamation.

This workflow does not attempt to define a full music- or video-focused lab or classroom build. Environments that need Logic Pro sound libraries, Motion templates, Final Cut Pro content, or other large creative assets can implement tested post-install workflows to preinstall that content after the managed app arrives. Those asset workflows can be implemented as an extension of this workflow, but should remain distinct from its entitlement and license- reclamation steps.

Adding Motion or Compressor next

The workflow scales without changing the shared scripts. For Motion, create:

  • Mac App – License Entitlement – Motion with APP_KEY="motion".
  • Mac App – License Scope – Motion with the EA criterion is Yes.
  • A Motion Mac App scoped only to that Smart Group.
  • A Motion add policy with $4=add, $5=motion, and a verified bundle path.
  • A Motion uninstall policy that removes the intended Motion bundle first, then uses $4=remove, $5=motion.

Compressor follows the same pattern with compressor as the app key. Apple continues to make one-time-purchase Mac versions of both Motion and Compressor available alongside Creator Studio, so they can follow the same device-assigned workflow. Apple Creator Studio deployment guidance

Troubleshooting and operational checks

 

Symptom Likely cause Where to look or what to do
The policy ran, but the Mac never enters the License Scope Smart Group. The marker was not created safely, policy $5 and EA APP_KEY differ, or Recon did not complete. Confirm the root-owned marker, compare the two app-key values, and verify that the inventory timestamp advanced.
The Mac is in the Smart Group, but the app does not arrive. No available license, delayed managed-app delivery, or a Mac App configuration/scope issue. Review available Apps and Books licenses, the Mac App status, and Management History.
The app appears installed immediately after a request. The bundle already existed; this is not proof of a new managed installation. Test on a Mac without that bundle and review Management History.
License reclamation does not occur. The app remains in another inclusion scope, the marker remains, or Recon has not reported No. Verify sole scope, remove the intended marker, run Recon, and confirm the EA result and Smart Group exit.
Recon stalls or takes far longer than expected. PI-1725 conditions, a slow or failing EA, or broad filesystem collection. Review the Recon prerequisite section, disable Include home directory sizes when appropriate, and audit EAs that call du or scan broad paths.
You need diagnostics for one request. The normal policy output is intentionally concise. Set $9=true for that test and inspect /var/log/jamf-mac-app-license-entitlement.log.
No Comments

Leave a Reply