> For the complete documentation index, see [llms.txt](https://docs.licensespring.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.licensespring.com/events-api/event-list/license-events.md).

# License Events

Events emitted across the license lifecycle, activation flow, expiry checks, and user assignments.

License events track a license from issuance through deletion. They also report activation, usage, expiry, and license-user changes.

Use the [event data objects](https://docs.licensespring.com/events-api/event-list/event-data-objects.md) reference for field definitions. For consumption events, see [consumption pool and offline checkout events](https://docs.licensespring.com/events-api/event-list/consumption-pool-and-offline-checkout-events.md).

### Lifecycle events

#### `license.created`

**Sent when:**

* an order is created in the vendor platform, with the Management API or through an integration: one event for each license in the order, including each license in a bundle,
* licenses are added to an existing order: one event for each new license,
* a device requests a trial and a new trial is issued.

**Not emitted when:** A trial request finds the device already has a trial for the product, so no new license is issued. The event is also not emitted for license keys generated without an order.

**Event data:** `license`, `request_info`

{% hint style="info" %}
The `license` object reflects the issued license. It has no `product`, `allow_overages`, or `max_overages`.
{% endhint %}

#### `license.updated`

**Sent when:**

* the license is edited in the vendor platform or with the Management API, including bulk edits and applying a license policy,
* the license is enabled or disabled, by you or by a license manager in the user portal,
* its consumptions are reset (Reset consumptions),
* it records consumption through Add Consumption. That call also sends `license.consumption_added`.

**Not emitted when:**

* features on the license are changed from the license page in the vendor platform (see [License feature events](https://docs.licensespring.com/events-api/events-list/license-feature-events)),
* a license user is assigned or removed (see `license.license_user.*` below),
* a device is reset, blacklisted or removed,
* the license is reset (that sends `license.reset`),
* consumptions are reset by the license's consumption period or by a pool reset,
* a scheduled update changes the license (that sends `scheduled_update.processed`),
* licenses are imported from a CSV file.

**Event data:** `license`

{% hint style="info" %}
For a bundle, enabling, disabling, and resetting consumptions emit one event for each license.
{% endhint %}

#### `license.reset`

**Sent when:** the license is reset from the vendor platform, with the Management API (single, bulk or custom bulk reset), or from the user portal by a license manager or, where you allow it, by the license's user. For a bundle, one more event is sent for each license in the bundle.

**What a reset does:** deactivates all devices, sets `active` to false and `times_activated` to 0, and removes the assigned user's activations. Depending on the reset options, it also clears the validity and maintenance periods, sets consumptions to zero, clears metadata, resets product features and removes custom field values.

**Not emitted when:** A single device is reset, a scheduled update resets the license, or only consumptions are reset. Resetting consumptions emits `license.updated`.

**Event data:** `license`, after the reset

#### `license.deleted`

**Sent when:** the license is deleted, one at a time or in bulk.

**Not emitted when:**

* the license is deleted because its order was deleted,
* the license is part of a bundle whose bundle license was deleted (only the bundle license sends the event),
* the license is air-gapped (bulk delete skips it).

**Event data:** `license`, as it was before the deletion

### Activation and usage events

These events originate from License API calls made by your application or SDK. They include device and request details.

#### `license.activated`

**Sent when:** a device activates the license, online (`activation_type: "online"`) or with an offline activation request (`"offline"`). It is sent for every successful activation call, also when the device was already active on the license. Activating a bundle sends one event for each license in the bundle.

**Not emitted when:** The activation fails, the call replays an earlier call with the same `Idempotency-Key`, or a trial key is issued without activation.

**Event data:** `license` with `activation_type` and `product`; `device`; `license_user` for user-based licenses only; and `request_info`.

{% hint style="info" %}
To count only new activations, compare `data.license.times_activated` with its previous value. Alternatively, track `data.device.hardware_id` for each license.
{% endhint %}

#### `license.checked`

**Sent when:** a device checks the license, on every successful check. Checking a bundle sends one event for each license in the bundle.

**Not emitted when:** The check fails, such as when the device is inactive, or the call replays a request with the same `Idempotency-Key`.

**Event data:** `license` with `product`; `device`; `license_user` for user-based licenses only; and `request_info`.

{% hint style="warning" %}
`license.checked` is emitted for every successful license check. A device can generate many events each day. Subscribe only if your endpoint can handle that volume.
{% endhint %}

#### `license.deactivated`

**Sent when:** a device deactivates the license, online (`deactivation_type: "online"`) or offline (`"offline"`). Deactivating a bundle sends one event for each license in the bundle.

**Not emitted when:** The device was inactive, an offline deactivation request is outdated, or the call replays a request with the same `Idempotency-Key`. Resetting a license or device in the platform also does not emit this event.

**Event data:** `license` with `deactivation_type`, `product`, and totals after reported consumption; `device`; `license_user` for user-based licenses only; `request_info`; and `consumption_info` when the device reports consumption.

#### `license.released`

**Sent when:** a device releases a floating cloud license.

**Not emitted when:** The floating slot times out, the device deactivates instead, or a floating feature is released.

**Event data:** `license` with `product`; `device`; `license_user` for user-based licenses only; and `request_info`.

### Expiry events

LicenseSpring checks expiry dates once a day, shortly after midnight UTC.

#### `license.will_expire_3_days` and `license.expired`

**Sent when:** the license's `validity_period` is 3 days from today (`will_expire_3_days`) or is today (`expired`), in UTC. "Expired" is sent on the expiry date itself.

**Only for activated licenses.** A license that was never activated, or was reset, sends neither event. Disabled licenses and trials do send them.

**Sent once per date.** If you move the expiry date, the events are sent again for the new date.

**Event data:** `license`. `initiator_type` and `initiator_id` are `null`.

#### `license.maintenance_will_expire_3_days` and `license.maintenance_expired`

The same rules as above, for `maintenance_period`, on licenses with a maintenance period enabled.

### License user events

These events are sent by the user portal service, also when you make the change from the vendor platform or the Management API.

#### `license.license_user.assigned`

**Sent when:** a license user is assigned to the license, one at a time, several at once (one event per user) or as a license user group (one event per group member). It is also sent when the user was already assigned.

**Not emitted when:** The product is not user-based, or the assignment fails, such as when the license has no user seats remaining.

**Event data:** `license_user`, `license`

{% hint style="info" %}
Assigning a user as a manager also emits `order.license_user.manager_assigned`.
{% endhint %}

#### `license.license_user.unassigned`

**Sent when:** a license user is removed from the license.

**Not emitted when:** The user was not assigned. Resetting the license also does not emit this event.

**Event data:** `license_user`, `license`


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.licensespring.com/events-api/event-list/license-events.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
