canonical: https://jentic.com/apis/cryptolens.io/cryptolens

# Cryptolens Web API

Jentic publishes the only available OpenAPI specification for Cryptolens Web API, keeping it validated and agent-ready. Cryptolens is a software licensing platform that issues per-customer license keys, activates them on machines, and exposes lifecycle controls like blocking, unblocking, and extending licenses. The catalogued slice covers the key, customer, and product resources with ten endpoints, and authentication is by access token passed as a query string parameter.

## For AI agents

Activate, block, and extend Cryptolens license keys, and manage the customers and products attached to them.

## Scope

Does not handle code obfuscation, payment processing, or DRM at the binary level - use for license key issuance, activation, and lifecycle management only.

## Capabilities

- Activate a Cryptolens license key on a customer machine and return a signed activation payload
- Deactivate a license key on a specific machine to free an activation slot when hardware changes
- Block a license key immediately after a chargeback or fraudulent purchase
- Unblock a previously blocked license once the dispute is resolved
- Extend a license expiry by a number of days when a customer renews or pays for an upgrade
- Create a new license key for a product with the desired feature flags and validity
- Add a customer record and tie it to one or more license keys for support attribution

## Use cases

### Per-Order License Provisioning

When an order is fulfilled in a payment processor like Stripe, the Cryptolens API issues a fresh license key, attaches it to the customer record, and returns a key string the order email template embeds. The licensing service handles activation enforcement client-side, and the API call slots cleanly into a webhook handler. Integration is small because the licensing flow only depends on the key, customer, and product resources.

Example prompt: Call `/key/CreateKey` with productId and the customer email to issue a key, then return the key field to the order fulfilment workflow.

### Hardware Switch Self-Service

Let customers move their software activation from an old laptop to a new one without a support ticket. The agent calls `/key/Deactivate` against the old machine fingerprint, then `/key/Activate` against the new one, returning the signed activation response that the desktop client stores. Because activation count limits are enforced server-side, the customer cannot exceed their entitled seats.

Example prompt: Call `/key/Deactivate` with the old MachineCode, then `/key/Activate` with the new MachineCode, and return the signed activation payload.

### Chargeback and Fraud Response

When a chargeback is filed, the support team needs to disable access immediately while the dispute is investigated. The Cryptolens API exposes `/key/BlockKey` for instant revocation and `/key/UnblockKey` to restore access if the dispute is resolved in the customer's favour. This avoids forcing engineering to manually update license records in a database.

Example prompt: Call `/key/BlockKey` with the productId and key string when the chargeback webhook fires, and `/key/UnblockKey` if the dispute is reversed.

### AI Agent License Self-Service

An AI agent in a customer success workflow can resolve common licensing tickets like activation, deactivation, and expiry extension without engineering involvement. Through Jentic the agent searches for the right Cryptolens operation, loads its schema, and executes against the access token stored in the vault. The query-string auth is invisible to the agent because Jentic appends it during execution.

Example prompt: Search Jentic for 'activate a Cryptolens license', load the `/key/Activate` operation, and execute it with productId, key, and MachineCode supplied by the customer.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/key/Activate` | Activate a license key on a machine |
| POST | `/key/Deactivate` | Deactivate a license key on a machine |
| POST | `/key/BlockKey` | Block a license key |
| POST | `/key/UnblockKey` | Unblock a previously blocked key |
| POST | `/key/ExtendLicense` | Extend the expiry date of a license |
| POST | `/key/CreateKey` | Create a new license key |
| POST | `/key/GetKey` | Retrieve a license key and its status |
| POST | `/customer/AddCustomer` | Create a customer record |

## Key resources

- **Key** — Activate, deactivate, block, unblock, extend, and create license keys
- **Customer** — Add and manage customer records linked to license keys
- **Product** — Reference products and policies that license keys are issued against

## Why Jentic

- **Setup:** Wiring the Cryptolens Web API by hand means threading its access token into the token query parameter on every call, targeting the api.cryptolens.io/api host, and handling retries yourself across license operations. Through Jentic you install once, import the Cryptolens Web API from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Cryptolens takes the license key in the request body rather than the URL path, so limit the agent to the operations it needs, such as activating a key or reading a key. You choose which operations are in scope, so destructive ones like blocking a key or deactivating a license are not included unless you add them.
- **Credential handling:** Your Cryptolens access token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'activate a software license' or 'create a license key', and Jentic returns the matching Cryptolens operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Cryptlex Web API** — Software licensing platform with bearer JWT auth and richer policy controls
- **Stripe API** — Subscription billing and payment processing
- **Paddle API** — Merchant of record for SaaS and software sales with built-in tax handling

## FAQ

### Why is there no official OpenAPI spec for Cryptolens Web API?

Cryptolens does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Cryptolens Web API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Cryptolens Web API use?

Cryptolens uses an access token supplied as the query string parameter named token. Tokens are issued from the Cryptolens dashboard. Through Jentic the token is stored in the vault and appended at execution time so it never appears in the agent context.

### Can I extend a license expiry through the Cryptolens Web API?

Yes. Call `/key/ExtendLicense` with the productId, key, and the number of days to add. The API returns the updated license expiry date, which the client app verifies on next activation.

### What are the rate limits for the Cryptolens Web API?

Cryptolens does not publish a hard request rate limit; activation throughput is governed by the plan's monthly activation quota. Inspect the dashboard for plan-level limits before bulk operations.

### How do I activate a license through Jentic?

Search Jentic for 'activate a Cryptolens license' and execute the loaded operation against `/key/Activate` with productId, key, and the MachineCode produced by the desktop client. Jentic injects the token query parameter from the vault.

### Is the Cryptolens Web API free?

Cryptolens has a free tier and paid plans that scale with active licenses. The Web API is included in every plan; pricing is published at https://cryptolens.io/pricing.

### How do I block a license after a refund?

Call `/key/BlockKey` with the productId and key when the refund webhook fires. The next call to `/key/Activate` from the client returns a blocked status, which the desktop app uses to disable access.

### Can I limit what my agent is allowed to do with the Cryptolens Web API?

Yes. Jentic One is self-hosted by you, so your own rules decide which Cryptolens operations and credentials the agent may use. You can grant only the endpoints the workflow needs, such as `/key/Activate` to activate a key or `/key/GetKey` to read one, while leaving destructive operations like `/key/BlockKey` and `/key/Deactivate` out of scope. Because Cryptolens takes the license key in the request body rather than the URL path, scoping is done at the operation level, and the access token stays with your instance and is injected only for the operations you allow.