# Examples (/examples)



import { Flame, AppWindow, WifiOff } from 'lucide-react';

This is a collection of example apps using Keyforge. You can use these examples as a reference for your own projects.

<Cards>
  <Card title="Electron app" icon={<AppWindow />} href="https://github.com/Nic13Gamer/keyforge-examples/tree/main/examples/electron-app" description="Basic desktop application built with Electron. Uses the Public API, no backend server required." />

  <Card title="Offline Electron app" icon={<WifiOff />} href="https://github.com/Nic13Gamer/keyforge-examples/tree/main/examples/offline-electron-app" description="Simple desktop application built with Electron. Licenses are validated offline. No backend server required." />
</Cards>


# Introduction (/)



Welcome to the Keyforge docs! This is a collection of guides and resources to help you get started with Keyforge and the API.

## Get started

Getting started is easy and only takes a few minutes. Here are some resources to help you get up and running quickly.

<Cards>
  <Card title="Quickstart" href="/quickstart" description="Set up Keyforge in your project within minutes." />

  <Card title="Examples" href="/examples" description="Example apps using the Keyforge API." />
</Cards>

### LLMs

AI agents can view the Keyforge documentation in Markdown by accessing [`llms-full.txt`](https://docs.keyforge.dev/llms-full.txt).

## Learn more

Some resources to help you learn more about Keyforge and its features.

<Cards>
  <Card title="Products" href="/products" description="Learn about products in Keyforge." />

  <Card title="Licenses" href="/licenses" description="Learn about licenses in Keyforge." />

  <Card title="Portal" href="/portal" description="Learn about the Keyforge portal." />

  <Card title="Payments" href="/addons/payments-one-time" description="Integrate with Stripe for payments." />

  <Card title="Offline licensing" href="/addons/license-token-no-sdk" description="Learn how to validate licenses while offline." />
</Cards>

## API Reference

Guides on how to use the Keyforge API.

<Cards>
  <Card title="Public API" href="/api-reference/public/public-validate-license" description="Manage licensing directly in your client application." />

  <Card title="Products" href="/api-reference/products/get-product" description="Manage products through the API." />

  <Card title="Licenses" href="/api-reference/licenses/validate-license" description="Manage licenses through the API." />

  <Card title="Portal" href="/api-reference/portal/create-private-session" description="Interact with the portal through the API." />
</Cards>


# Licenses (/licenses)



Each license is associated with a product and can be activated on a defined number of devices. A license can also have an email associated with it, allowing customers to manage their licenses in the [portal](/portal).

## License types

Keyforge currently supports two types of licenses:

* **Perpetual**: A license that never expires.
* **Timed**: A license that expires at a specific date.

## Devices

A license can be activated on multiple devices, as defined by the maximum active devices.

Each active device on a license has 3 properties:

* **Identifier**: A unique identifier for the device. Must have at most 96 characters.
* **Name**: A name for the device. Does not need to be unique. Must have at most 64 characters.
* **Activation date**: The date when the device was activated.

<Callout title="Device identifier">
  The device identifier needs to be unique inside the license scope. There are
  various ways to get a unique identifier, such as the MAC address, HWID, serial
  number, or a randomly generated UUID stored in the device.
</Callout>


# Portal (/portal)



Customers can view and manage their licenses in the Keyforge portal. To access it, customers can request an email with a link to the portal. All licenses linked to their email address will be available.

<Callout title="Hide products">
  If you prefer not to make your products available for customers to manage in
  the portal, you can hide them in the
  [dashboard](https://keyforge.dev/dashboard/portal). You can also prevent
  customers from resetting active devices.
</Callout>

<ImageZoom src="https://static.keyforge.dev/docs-portal-showcase.gif" alt="Keyforge portal showcase" width={1920} height={1080} unoptimized />

## Accessing the portal

To access the portal, customers must request an access link via email. This link is valid for 2 hours. Customers can request the portal access link here: [https://keyforge.dev/portal/request](https://keyforge.dev/portal/request).

<Callout title="Pre-fill email">
  You can pre-fill the email field in the portal request form by adding the
  `email` query parameter to the URL. For example:
  [https://keyforge.dev/portal/request?email=john-doe@example.com](https://keyforge.dev/portal/request?email=john-doe@example.com).
</Callout>

<ImageZoom src="https://static.keyforge.dev/docs-portal-request.png" alt="Keyforge portal request" width={1920} height={1080} unoptimized />

### Private sessions

You can also create a private portal session for a specific email address via the [dashboard](https://keyforge.dev/dashboard/portal) or [API](/api-reference/portal/create-private-session). Customers will only be able to view and manage licenses from your products. The generated link is valid for 12 hours.


# Products (/products)



A product is a software or service that you want to license and distribute to your customers.

## Customization

### Support email

A customer support email displayed in purchase emails and the portal. It's optional, but if not provided, customers will be instructed to contact you through your Keyforge account email.

### Purchase note

A note displayed in purchase emails and the portal, usually to guide customers on how to activate their license.

### Action button

A button displayed in purchase emails and the portal, usually used as a download button. You can define its text and link.

<Callout>
  You can add the license key to the action button link by using the `{key}`
  placeholder. For example, `https://example.com/download?key={key}`.
</Callout>

## Purchase email example

Here is an example of a customized purchase email sent to customers:

<ImageZoom src="https://static.keyforge.dev/docs-product-purchase-email.png" alt="Purchase email example" width={364} height={550} unoptimized />

<Callout title="Product image">
  If you're in the **Plus** tier, you can add an image to your product. This
  image is currently only displayed in purchase emails.
</Callout>


# Quickstart (/quickstart-server)



You can set up Keyforge in your project within minutes. This guide will walk you through the steps to get started.

Choose whether to integrate Keyforge directly in your client or server.

<PageSelect
  pages={[
  {
    href: '/quickstart',
    title: 'Client-side',
    description:
      'Integrate Keyforge into a desktop app, browser extension, or anything else.',
  },
  {
    href: '/quickstart-server',
    title: 'Server-side',
    description:
      'Set up Keyforge in a backend server, API, or any other server-side application.',
  },
]}
/>

***

## Managing licenses in the server

To manage licenses in your server, use the Keyforge API. You need an API key to use it.

### Prerequisites

Before you begin, make sure you have completed the following steps:

* Get an API key [here](https://keyforge.dev/dashboard/api-keys).
* Create a product [here](https://keyforge.dev/dashboard/products).

<Steps>
  <Step>
    ### Create a license

    In this example, we will create a license that never expires and can only have 1 device active at the same time. Copy the returned license key.

    <CodeBlockTabs defaultValue="cURL">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="cURL">
          cURL
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="JavaScript">
          JavaScript
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="cURL">
        ```bash
        curl -X POST https://keyforge.dev/api/v1/licenses \
          -H "Authorization: Bearer sk_1234" \
          -H "Content-Type: application/json" \
          -d '{
            "productId": "p_123456",
            "type": "perpetual",
            "maxDevices": 1,
            "email": "john-doe@example.com"
          }'
        ```
      </CodeBlockTab>

      <CodeBlockTab value="JavaScript">
        ```js
        const res = await fetch('https://keyforge.dev/api/v1/licenses', {
          method: 'POST',
          headers: {
            Authorization: 'Bearer sk_1234',
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            productId: 'p_123456',
            type: 'perpetual',
            maxDevices: 1,
            email: 'john-doe@example.com',
          }),
        });

        const license = await res.json();
        console.log(license.key);
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    <Accordions>
      <Accordion title="Example response">
        Example response from the API when creating a license:

        ```json
        {
          "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
          "userId": "05d27bfb-61c7-45f7-9d07-09a41defc88a",
          "productId": "p_123456",
          "type": "perpetual",
          "expiresAt": null,
          "revoked": false,
          "email": "john-doe@example.com",
          "maxDevices": 1,
          "activeDevices": [],
          "createdAt": "2024-05-19T18:39:33.000Z"
        }
        ```
      </Accordion>
    </Accordions>
  </Step>

  <Step>
    ### Activate a license

    Activate the license you have just created. Replace `LICENSE_KEY` with the license key you copied in the previous step. In this example, we will activate the license on a device with the identifier `some_device_id` and the name `My computer name`.

    <CodeBlockTabs defaultValue="cURL">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="cURL">
          cURL
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="JavaScript">
          JavaScript
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="cURL">
        ```bash
        curl -X POST "https://keyforge.dev/api/v1/licenses/activate" \
          -H "Authorization: Bearer sk_1234" \
          -H "Content-Type: application/json" \
          -H "License-Key: LICENSE_KEY" \
          -d '{
            "productId": "p_123456",
            "device": {
              "identifier": "some_device_id",
              "name": "My computer name"
            }
          }'
        ```
      </CodeBlockTab>

      <CodeBlockTab value="JavaScript">
        ```js
        await fetch('https://keyforge.dev/api/v1/licenses/activate', {
          method: 'POST',
          headers: {
            Authorization: 'Bearer sk_1234',
            'Content-Type': 'application/json',
            'License-Key': 'LICENSE_KEY',
          },
          body: JSON.stringify({
            productId: 'p_123456',
            device: {
              identifier: 'some_device_id',
              name: 'My computer name',
            },
          }),
        });
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    <Accordions>
      <Accordion title="Example response">
        Example response from the API when activating a license:

        ```json
        {
          "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
          "userId": "05d27bfb-61c7-45f7-9d07-09a41defc88a",
          "productId": "p_123456",
          "type": "perpetual",
          "expiresAt": null,
          "revoked": false,
          "email": "john-doe@example.com",
          "maxDevices": 1,
          "activeDevices": [
            {
              "identifier": "some_device_id",
              "name": "My computer name",
              "activatedAt": "2024-05-19T18:39:33.000Z"
            }
          ],
          "createdAt": "2024-05-19T18:39:33.000Z"
        }
        ```
      </Accordion>
    </Accordions>
  </Step>

  <Step>
    ### Validate a license

    Validate the license you have just activated. Replace `LICENSE_KEY` with the license key. In this example, we will verify the license on the device with the identifier `some_device_id`.

    <CodeBlockTabs defaultValue="cURL">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="cURL">
          cURL
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="JavaScript">
          JavaScript
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="cURL">
        ```bash
        curl -X POST "https://keyforge.dev/api/v1/licenses/validate" \
          -H "Authorization: Bearer sk_1234" \
          -H "Content-Type: application/json" \
          -H "License-Key: LICENSE_KEY" \
          -d '{
            "productId": "p_123456",
            "deviceIdentifier": "some_device_id"
          }'
        ```
      </CodeBlockTab>

      <CodeBlockTab value="JavaScript">
        ```js
        const res = await fetch('https://keyforge.dev/api/v1/licenses/validate', {
          method: 'POST',
          headers: {
            Authorization: 'Bearer sk_1234',
            'Content-Type': 'application/json',
            'License-Key': 'LICENSE_KEY',
          },
          body: JSON.stringify({
            productId: 'p_123456',
            deviceIdentifier: 'some_device_id',
          }),
        });

        const validation = await res.json();
        console.log(validation.isValid);
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    <Accordions>
      <Accordion title="Example response">
        Example response from the API when validating a license:

        ```json
        {
          "isValid": true,
          "status": "active",
          "device": {
            "identifier": "some_device_id",
            "name": "My computer name",
            "activationDate": "2024-05-19T18:39:33.000Z"
          },
          "license": {
            "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "userId": "05d27bfb-61c7-45f7-9d07-09a41defc88a",
            "productId": "p_123456",
            "type": "perpetual",
            "expiresAt": null,
            "revoked": false,
            "email": "john-doe@example.com",
            "maxDevices": 1,
            "activeDevices": [
              {
                "identifier": "some_device_id",
                "name": "My computer name",
                "activationDate": "2024-05-19T18:39:33.000Z"
              }
            ],
            "createdAt": "2024-05-19T18:39:33.000Z"
          }
        }
        ```
      </Accordion>
    </Accordions>
  </Step>

  <Step>
    ### Congratulations! 🎉

    You have successfully created, activated, and validated your first license. You can manage all licenses in the [dashboard](https://keyforge.dev/dashboard/licenses).
  </Step>
</Steps>

## Learn more

### Next steps

Some features to explore and extend your licensing system.

<Cards>
  <Card title="Integrate with Stripe" href="/addons/payments-one-time" description="Generate licenses on purchases and subscriptions." />

  <Card title="Offline licensing" href="/addons/license-token-no-sdk" description="Validate licenses without internet access." />
</Cards>

### Public API

Keyforge also provides a public API that you can use directly in your app, without the need to create a backend.

<Cards>
  <Card title="Validate license" href="/api-reference/public/public-validate-license" description="Verify if a license is valid." />

  <Card title="Activate license" href="/api-reference/public/public-activate-license" description="Activate a license for a device." />
</Cards>

### API Reference

Learn more about the Keyforge API.

<Cards>
  <Card title="Products" href="/api-reference/products/get-product" description="Manage products through the Keyforge API." />

  <Card title="Licenses" href="/api-reference/licenses/validate-license" description="Manage licenses through the Keyforge API." />

  <Card title="Portal" href="/api-reference/portal/create-private-session" description="Interact with the portal through the Keyforge API." />
</Cards>


# Quickstart (/quickstart)



You can set up Keyforge in your project within minutes. This guide will walk you through the steps to get started.

Choose whether to integrate Keyforge directly in your client or server.

<PageSelect
  pages={[
  {
    href: '/quickstart',
    title: 'Client-side',
    description:
      'Integrate Keyforge into a desktop app, browser extension, or anything else.',
  },
  {
    href: '/quickstart-server',
    title: 'Server-side',
    description:
      'Set up Keyforge in a backend server, API, or any other server-side application.',
  },
]}
/>

***

## Licensing a client application

To validate and activate licenses in the client, use the [Public API](/api-reference/public/public-validate-license) directly in your app. You can use this API anywhere, with any programming language.

### Prerequisites

Before you begin, make sure you have completed the following steps:

* Create a product [here](https://keyforge.dev/dashboard/products).
* Create a license [here](https://keyforge.dev/dashboard/licenses).

<Steps>
  <Step>
    ### Activate a license

    The first time a user opens your app, they should be prompted to activate their license.

    The device identifier needs to be unique inside the license scope. You can use a MAC address, HWID, or any other type of identifier that is unique to a device.

    <CodeBlockTabs defaultValue="cURL">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="cURL">
          cURL
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="JavaScript">
          JavaScript
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Python">
          Python
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Go">
          Go
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Swift">
          Swift
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Rust">
          Rust
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="cURL">
        ```bash
        curl -X POST https://keyforge.dev/api/v1/public/licenses/activate \
          -H "Content-Type: application/json" \
          -d '{
            "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "deviceIdentifier": "some_device_id",
            "deviceName": "My device",
            "productId": "p_123456"
          }'
        ```
      </CodeBlockTab>

      <CodeBlockTab value="JavaScript">
        ```js
        await fetch('https://keyforge.dev/api/v1/public/licenses/activate', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            licenseKey: 'ABCDE-ABCDE-ABCDE-ABCDE-ABCDE',
            deviceIdentifier: 'some_device_id',
            deviceName: 'My device',
            productId: 'p_123456',
          }),
        });

        console.log('License activated');
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Python">
        ```py
        import requests

        requests.post(
          'https://keyforge.dev/api/v1/public/licenses/activate',
          json={
            'licenseKey': 'ABCDE-ABCDE-ABCDE-ABCDE-ABCDE',
            'deviceIdentifier': 'some_device_id',
            'deviceName': 'My device',
            'productId': 'p_123456',
          },
          headers={
            'Content-Type': 'application/json',
          },
        )

        print('License activated')
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Go">
        ```go
        package main

        import (
          "bytes"
          "encoding/json"
          "fmt"
          "io/ioutil"
          "net/http"
        )

        func main() {
          data := map[string]string{
            "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "deviceIdentifier": "some_device_id",
            "deviceName": "My device",
            "productId": "p_123456",
          }

          jsonData, _ := json.Marshal(data)
          req, _ := http.NewRequest("POST", "https://keyforge.dev/api/v1/public/licenses/activate", bytes.NewBuffer(jsonData))
          req.Header.Set("Content-Type", "application/json")

          client := &http.Client{}
          resp, err := client.Do(req)
          if err != nil {
            fmt.Println("Request failed:", err)
            return
          }
          defer resp.Body.Close()

          body, _ := ioutil.ReadAll(resp.Body)
          if resp.StatusCode == http.StatusOK {
            fmt.Println("License activated successfully:", string(body))
          } else {
            fmt.Println("Error activating license:", resp.Status, string(body))
          }
        }
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Swift">
        ```swift
        import Foundation

        Task {
            let url = URL(string: "https://keyforge.dev/api/v1/public/licenses/activate")!
            var request = URLRequest(url: url)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")

            let body: [String: Any] = [
                "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
                "deviceIdentifier": "some_device_id",
                "deviceName": "My device",
                "productId": "p_123456"
            ]

            request.httpBody = try! JSONSerialization.data(withJSONObject: body)

            _ = try! await URLSession.shared.data(for: request)
            print("License activated")
        }
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Rust">
        ```rust
        use reqwest::Client;
        use serde_json::json;

        #[tokio::main]
        async fn main() {
            let client = Client::new();

            client
                .post("https://keyforge.dev/api/v1/public/licenses/activate")
                .json(&json!({
                    "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
                    "deviceIdentifier": "some_device_id",
                    "deviceName": "My device",
                    "productId": "p_123456"
                }))
                .send()
                .await
                .unwrap();

            println!("License activated");
        }
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    <Callout>
      The `productId` property can also be an array of IDs if your app supports
      multiple products, like different tiers.
    </Callout>

    <Accordions>
      <Accordion title="Example response">
        Example response from the API if the activation is successful.

        ```json
        {
          "isValid": true,
          "device": {
            "identifier": "some_device_id",
            "name": "My computer name",
            "activationDate": "2023-05-19T18:39:33.000Z"
          },
          "license": {
            "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "productId": "p_123456",
            "type": "perpetual",
            "revoked": false,
            "maxDevices": 5,
            "expiresAt": null,
            "createdAt": "2023-05-19T18:39:33.000Z"
          }
        }
        ```

        If the activation is successful, `isValid` is always `true`. The `device` and `license` properties will never be `null` in this case.
      </Accordion>
    </Accordions>
  </Step>

  <Step>
    ### Validate a license

    When your app starts, you can verify the license to check if it's valid.

    You can validate a license whenever you like, for example, every hour, to ensure that it is still valid.

    <CodeBlockTabs defaultValue="cURL">
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="cURL">
          cURL
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="JavaScript">
          JavaScript
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Python">
          Python
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Go">
          Go
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Swift">
          Swift
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="Rust">
          Rust
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="cURL">
        ```bash
        curl -X POST https://keyforge.dev/api/v1/public/licenses/validate \
          -H "Content-Type: application/json" \
          -d '{
            "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "deviceIdentifier": "some_device_id",
            "productId": "p_123456"
          }'
        ```
      </CodeBlockTab>

      <CodeBlockTab value="JavaScript">
        ```js
        const res = await fetch(
          'https://keyforge.dev/api/v1/public/licenses/validate',
          {
            method: 'POST',
            headers: {
              'Content-Type': 'application/json',
            },
            body: JSON.stringify({
              licenseKey: 'ABCDE-ABCDE-ABCDE-ABCDE-ABCDE',
              deviceIdentifier: 'some_device_id',
              productId: 'p_123456',
            }),
          }
        );

        const data = await res.json();

        console.log(data.isValid);
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Python">
        ```py
        import requests

        res = requests.post(
          'https://keyforge.dev/api/v1/public/licenses/validate',
          json={
            'licenseKey': 'ABCDE-ABCDE-ABCDE-ABCDE-ABCDE',
            'deviceIdentifier': 'some_device_id',
            'productId': 'p_123456',
          },
          headers={
            'Content-Type': 'application/json',
          },
        )

        data = res.json()

        print(data['isValid'])
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Go">
        ```go
        package main

        import (
          "bytes"
          "encoding/json"
          "fmt"
          "net/http"
        )

        func main() {
          data := map[string]string{
            "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "deviceIdentifier": "some_device_id",
            "productId": "p_123456",
          }

          jsonData, _ := json.Marshal(data)
          req, _ := http.NewRequest("POST", "https://keyforge.dev/api/v1/public/licenses/validate", bytes.NewBuffer(jsonData))
          req.Header.Set("Content-Type", "application/json")

          client := &http.Client{}
          resp, err := client.Do(req)
          if err != nil {
            fmt.Println("Request failed:", err)
            return
          }
          defer resp.Body.Close()

          var result map[string]interface{}
          json.NewDecoder(resp.Body).Decode(&result)

          fmt.Println(result["isValid"])
        }
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Swift">
        ```swift
        import Foundation

        Task {
            let url = URL(string: "https://keyforge.dev/api/v1/public/licenses/validate")!
            var request = URLRequest(url: url)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")

            let body: [String: Any] = [
                "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
                "deviceIdentifier": "some_device_id",
                "productId": "p_123456"
            ]

            request.httpBody = try! JSONSerialization.data(withJSONObject: body)

            let (data, _) = try! await URLSession.shared.data(for: request)
            let json = try! JSONSerialization.jsonObject(with: data) as! [String: Any]

            print(json["isValid"] ?? "Missing isValid")
        }
        ```
      </CodeBlockTab>

      <CodeBlockTab value="Rust">
        ```rust
        use reqwest::Client;
        use serde_json::json;

        #[tokio::main]
        async fn main() {
            let client = Client::new();

            let res = client
                .post("https://keyforge.dev/api/v1/public/licenses/validate")
                .json(&json!({
                    "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
                    "deviceIdentifier": "some_device_id",
                    "productId": "p_123456"
                }))
                .send()
                .await
                .unwrap()
                .json::<serde_json::Value>()
                .await
                .unwrap();

            println!("{}", res["isValid"]);
        }
        ```
      </CodeBlockTab>
    </CodeBlockTabs>

    <Callout>
      The `productId` property can also be an array of IDs if your app supports
      multiple products, like different tiers.
    </Callout>

    <Accordions>
      <Accordion title="Example response">
        Example response from the API if the license is valid.

        ```json
        {
          "isValid": true,
          "device": {
            "identifier": "some_device_id",
            "name": "My computer name",
            "activationDate": "2023-05-19T18:39:33.000Z"
          },
          "license": {
            "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "productId": "p_123456",
            "type": "perpetual",
            "revoked": false,
            "maxDevices": 5,
            "expiresAt": null,
            "createdAt": "2023-05-19T18:39:33.000Z"
          }
        }
        ```

        The `device` and `license` properties will be `null` if the license is not valid.
      </Accordion>
    </Accordions>
  </Step>

  <Step>
    ### Congratulations! 🎉

    You have successfully activated and validated your first license inside your app. You can manage all licenses in the [dashboard](https://keyforge.dev/dashboard/licenses).
  </Step>
</Steps>

## Learn more

### Next steps

Some features to explore and extend your licensing system.

<Cards>
  <Card title="Integrate with Stripe" href="/addons/payments-one-time" description="Generate licenses on purchases and subscriptions." />

  <Card title="Offline licensing" href="/addons/license-token-no-sdk" description="Validate licenses without internet access." />
</Cards>

### Public API

Learn more about the Public API. An API key is not needed to use it.

<Cards>
  <Card title="Validate license" href="/api-reference/public/public-validate-license" description="Verify if a license is valid." />

  <Card title="Activate license" href="/api-reference/public/public-activate-license" description="Activate a license for a device." />
</Cards>


# Offline licensing (/addons/license-token-js-sdk)



It's common to have apps that need to work even without an internet connection. Keyforge makes it easy to validate licenses oflline.

To make this possible, Keyforge can issue a signed **license token** that can be verified on the client. The token is a JWT and contains information about the license.

<Callout>
  An internet connection is only required to activate the license and to
  occasionally refresh the license token.
</Callout>

## Getting started

There is a client SDK available for JavaScript, but license tokens can be used in any programming language that supports JWTs.

<PageSelect
  pages={[
  {
    href: '/addons/license-token-no-sdk',
    title: 'No SDK',
    description: 'Generate and verify license tokens without a client SDK.',
  },
  {
    href: '/addons/license-token-js-sdk',
    title: 'JavaScript SDK',
    description: 'Use the client-side SDK to manage license tokens.',
  },
]}
/>

<Steps>
  <Step>
    ### Configure license tokens for a product

    Go to [license tokens](https://keyforge.dev/dashboard/addons/license-token) and add a new product. You can edit how much time a token will be valid for, and other options after creating the new configuration.

    <Callout>
      For setups with more than one product, you can duplicate the signing key pair
      from another product inside the **edit** menu. You can also import an external
      key pair.
    </Callout>
  </Step>

  <Step>
    ### Install the client SDK

    Install the Keyforge client SDK in your project:

    <CodeBlockTabs defaultValue="npm" groupId="package-manager" persist>
      <CodeBlockTabsList>
        <CodeBlockTabsTrigger value="npm">
          npm
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="pnpm">
          pnpm
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="yarn">
          yarn
        </CodeBlockTabsTrigger>

        <CodeBlockTabsTrigger value="bun">
          bun
        </CodeBlockTabsTrigger>
      </CodeBlockTabsList>

      <CodeBlockTab value="npm">
        ```bash
        npm i @keyforge/client
        ```
      </CodeBlockTab>

      <CodeBlockTab value="pnpm">
        ```bash
        pnpm add @keyforge/client
        ```
      </CodeBlockTab>

      <CodeBlockTab value="yarn">
        ```bash
        yarn add @keyforge/client
        ```
      </CodeBlockTab>

      <CodeBlockTab value="bun">
        ```bash
        bun add @keyforge/client
        ```
      </CodeBlockTab>
    </CodeBlockTabs>
  </Step>

  <Step>
    ### Retrieve initial token

    The simplest way to get and store the first license token for a device is after activating a license. The SDK provides `activateLicense`.

    ```js
    import { activateLicense } from '@keyforge/client';

    const { isValid, token } = await activateLicense({
      licenseKey: 'ABCDE-ABCDE-ABCDE-ABCDE-ABCDE',
      deviceIdentifier: 'some_device_id',
      deviceName: 'My device',
      productId: 'p_123456',
    });

    if (isValid && token) {
      storeToken(token); // Store the token on the device

      console.log('License activated successfully!');
    }
    ```
  </Step>

  <Step>
    ### Validate and refresh tokens

    The SDK provides a simple way to validate and automatically refresh license tokens. You should call `validateAndRefreshToken` when your app starts.

    ```js
    import { validateAndRefreshToken } from '@keyforge/client/token';

    const PUBLIC_KEY = '...'; // Copied from the dashboard. In JSON string or object format

    const { isValid, token, data, isValidButExpired } =
      await validateAndRefreshToken({
        token: getStoredToken(), // The current license token
        publicKeyJwk: PUBLIC_KEY,
        deviceIdentifier: 'some_device_id',
        productId: 'p_123456',
      });

    if (isValid) {
      storeToken(token); // Store the new token if it was refreshed

      console.log('License token is valid!', data.license.key);
    } else if (!isValidButExpired) {
      // A network error probably occurred. The token is expired, but was valid
      // You should NOT prompt the user to activate a license
    }

    // If the token is not valid, you should prompt the user to activate a license
    ```

    <Accordions>
      <Accordion title="Periodic token checks">
        For periodic token checks, it's not recommended to use `validateAndRefreshToken`. Instead, use `verifyToken`, which only checks the validity of the token without refreshing it.

        ```js
        import { verifyToken } from '@keyforge/client/token';

        const PUBLIC_KEY = '...';

        const { isValid, data } = await verifyToken({
          token: getStoredToken(),
          publicKeyJwk: PUBLIC_KEY,
          deviceIdentifier: 'some_device_id',
          productId: 'p_123456',
        });

        if (isValid) {
          console.log('License token is valid!', data.license.key);
        }
        ```
      </Accordion>

      <Accordion title="Retrieve new token">
        To retrieve a new token from the Keyforge API, you can use `fetchToken`.

        ```js
        import { fetchToken } from '@keyforge/client/token';

        const { isValid, token } = await fetchToken({
          licenseKey: 'ABCDE-ABCDE-ABCDE-ABCDE-ABCDE',
          deviceIdentifier: 'some_device_id',
          productId: 'p_123456',
        });

        if (isValid) {
          storeToken(token);
        }
        ```

        <Callout>
          The `fetchToken` function does not verify if the new token is valid. You
          should always verify the new token.
        </Callout>
      </Accordion>
    </Accordions>
  </Step>
</Steps>

## Learn more

### Example

An example desktop app built with Electron using the client SDK and license tokens is available [here](https://github.com/Nic13Gamer/keyforge-examples/tree/main/examples/offline-electron-app).

### API Reference

<Cards>
  <Card title="Get license token" href="/api-reference/public/public-license-token" description="Generate a new signed license token." />

  <Card title="Get license token public key" href="/api-reference/public/public-product-license-token-public-key" description="Get the public key used to verify license tokens for a product." />
</Cards>


# Offline licensing (/addons/license-token-no-sdk)



It's common to have apps that need to work even without an internet connection. Keyforge makes it easy to validate licenses oflline.

To make this possible, Keyforge can issue a signed **license token** that can be verified on the client. The token is a JWT and contains information about the license.

<Callout>
  An internet connection is only required to activate the license and to
  occasionally refresh the license token.
</Callout>

## Getting started

There is a client SDK available for JavaScript, but license tokens can be used in any programming language that supports JWTs.

<PageSelect
  pages={[
  {
    href: '/addons/license-token-no-sdk',
    title: 'No SDK',
    description: 'Generate and verify license tokens without a client SDK.',
  },
  {
    href: '/addons/license-token-js-sdk',
    title: 'JavaScript SDK',
    description: 'Use the client-side SDK to manage license tokens.',
  },
]}
/>

<Steps>
  <Step>
    ### Configure license tokens for a product

    Go to [license tokens](https://keyforge.dev/dashboard/addons/license-token) and add a new product. You can edit how much time a token will be valid for, and other options after creating the new configuration.

    <Callout>
      For setups with more than one product, you can duplicate the signing key pair
      from another product inside the **edit** menu. You can also import an external
      key pair.
    </Callout>
  </Step>

  <Step>
    ### Retrieve initial token

    The simplest way to get and store the first license token for a device is after activating a license. You should use the [activate license](/api-reference/public/activate-license) API endpoint.

    ```bash
    curl -X POST https://keyforge.dev/api/v1/public/licenses/activate \
      -H "Content-Type: application/json" \
      -d '{
        "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
        "deviceIdentifier": "some_device_id",
        "deviceName": "My device",
        "productId": "p_123456"
      }'
    ```

    A `token` property will be returned in the response. Store this token in the device's storage.

    <Accordions>
      <Accordion title="Example response">
        Example response from the API if the activation is successful.

        ```json
        {
          "isValid": true,
          "token": "...", // The license token
          "device": {
            "identifier": "some_device_id",
            "name": "My device",
            "activationDate": "2023-05-19T18:39:33.000Z"
          },
          "license": {
            "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
            "productId": "p_123456",
            "type": "perpetual",
            "revoked": false,
            "maxDevices": 5,
            "expiresAt": null,
            "createdAt": "2023-05-19T18:39:33.000Z"
          }
        }
        ```
      </Accordion>
    </Accordions>
  </Step>

  <Step>
    ### Verify the token

    To verify the token, you can use any [JWT library](https://jwt.io/libraries) available in your programming language. Here are some tips you should follow:

    * The token is signed using an **ES256** key pair. The public key is in the [dashboard](https://keyforge.dev/dashboard/addons/license-token).
    * Check the `exp` claim to see if the token is still valid.
    * Check the `productId` and `deviceIdentifier` to make sure the token is valid for the current product and device.
    * Do not ask the user to activate a license if the token is expired but was valid at some point.

    <Callout>
      The token should be verified when the app starts, but it can also be verified
      periodically.
    </Callout>
  </Step>

  <Step>
    ### Refresh the token

    The token needs to be refreshed periodically to ensure it remains valid. Use the [license token](/api-reference/public/license-token) API endpoint.

    <Callout>
      You should refresh the token some time before it expires, for example, 3 days
      before the expiration date.
    </Callout>

    ```bash
    curl -X POST https://keyforge.dev/api/v1/public/licenses/token \
      -H "Content-Type: application/json" \
      -d '{
        "licenseKey": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
        "deviceIdentifier": "some_device_id",
        "productId": "p_123456"
      }'
    ```

    A `token` property will be returned in the response. Store this token in the device's storage.

    <Accordions>
      <Accordion title="Example response">
        Example response from the API if the token was signed successfully.

        ```json
        {
          "isValid": true,
          "token": "..." // The license token
        }
        ```
      </Accordion>
    </Accordions>
  </Step>
</Steps>

## Learn more

### Token payload

A license token contains the following data:

```json
{
  "license": {
    "key": "ABCDE-ABCDE-ABCDE-ABCDE-ABCDE",
    "productId": "p_123456",
    "type": "perpetual",
    "expiresAt": null,
    "createdAt": 1684521573, // Unix timestamp in seconds
    "maxDevices": 5,
    "email": null
  },
  "device": {
    "identifier": "some_device_id",
    "name": "My device",
    "activationDate": 1684521573 // Unix timestamp in seconds
  }
}
```

<Callout>
  There are also some additional claims in the token, such as `exp` (expiration
  time) and `iat` (issued at time). It is signed using the **ES256** algorithm.
</Callout>

### API Reference

<Cards>
  <Card title="Get license token" href="/api-reference/public/public-license-token" description="Generate a new signed license token." />

  <Card title="Get license token public key" href="/api-reference/public/public-product-license-token-public-key" description="Get the public key used to verify license tokens for a product." />
</Cards>


# Payments (/addons/payments-one-time)



<Callout>
  Keyforge uses Stripe restricted API keys with only the necessary permissions.
  The secret keys are securely stored and encrypted with AES-256.
</Callout>

Keyforge integrates with Stripe for automatic license generation. No code or webhook setup needed.

<PageSelect
  pages={[
  {
    href: '/addons/payments-one-time',
    title: 'One-time purchases',
    description:
      'Accept one-time payments and automatically generate licenses.',
  },
  {
    href: '/addons/payments-subscription',
    title: 'Subscriptions',
    description:
      'Accept recurring payments and generate subscription licenses.',
  },
]}
/>

***

## Setup one-time purchases

Upon purchasing a Stripe product, a license is automatically created on Keyforge, and the customer receives a thank you email with the license key.

Make sure you have a Stripe account, a product set up on Stripe, and a corresponding product on Keyforge.

<Steps>
  <Step>
    ### Connect Stripe account

    Go to [payments](https://keyforge.dev/dashboard/integrations/stripe) and click on "Connect account". A Stripe webhook pointing to Keyforge will be automatically created.

    <ImageZoom src="https://static.keyforge.dev/docs-stripe-integration-connect-account.png" alt="Connect Stripe account" width={1920} height={1080} unoptimized />
  </Step>

  <Step>
    ### Connect Stripe product

    Click on "Connect product".

    Your Stripe accounts and products with their prices will be automatically listed. Select the Stripe product price and the corresponding Keyforge product that customers will receive a license for upon purchase.

    Choose the options for the created licenses.

    <ImageZoom src="https://static.keyforge.dev/docs-stripe-integration-connect-product.png" alt="Connect Stripe product" width={1920} height={1080} unoptimized />
  </Step>

  <Step>
    ### You're done! 🎉

    It's as simple as that! Create a payment link for your product and start selling. When a customer purchases the product, a license will be automatically created on Keyforge and they will get emailed the license key.
  </Step>
</Steps>

## Learn more

### Timed licenses

You can choose between two options for creating timed licenses using the Stripe integration:

1. **Offset**: The expiration date of the license will be set to the creation date plus the defined offset.
2. **Fixed**: All created licenses will share the same expiration date, as specified in the options.

<Callout type="warn" title="Fixed timed licenses">
  If a customer purchases a fixed timed license that has already expired, they
  will get an inactive license that **will not work**.
</Callout>

### Invoices

If you enable invoice generation in the Stripe payment link, customers will be able to download their invoice from the [portal](/portal). You can also download the invoice from the dashboard.


# Payments (/addons/payments-subscription)



<Callout>
  Keyforge uses Stripe restricted API keys with only the necessary permissions.
  The secret keys are securely stored and encrypted with AES-256.
</Callout>

Keyforge integrates with Stripe for automatic license generation. No code or webhook setup needed.

<PageSelect
  pages={[
  {
    href: '/addons/payments-one-time',
    title: 'One-time purchases',
    description:
      'Accept one-time payments and automatically generate licenses.',
  },
  {
    href: '/addons/payments-subscription',
    title: 'Subscriptions',
    description:
      'Accept recurring payments and generate subscription licenses.',
  },
]}
/>

***

## Setup subscriptions

Upon subscribing to a Stripe product, a license is automatically created on Keyforge, and the customer receives a thank you email with the license key.

Make sure you have a Stripe account, a recurring product set up on Stripe, and a corresponding product on Keyforge.

<Steps>
  <Step>
    ### Connect Stripe account

    Go to [payments](https://keyforge.dev/dashboard/integrations/stripe) and click on "Connect account". A Stripe webhook pointing to Keyforge will be automatically created.

    <ImageZoom src="https://static.keyforge.dev/docs-stripe-integration-connect-account.png" alt="Connect Stripe account" width={1920} height={1080} unoptimized />
  </Step>

  <Step>
    ### Connect Stripe subscription

    Click on "Connect product".

    Your Stripe accounts and products with their prices will be automatically listed. Select the Stripe recurring price and the corresponding Keyforge product that customers will receive a license for upon subscribing.

    <Callout type="warn">
      Don't forget to enable the [billing
      portal](https://dashboard.stripe.com/settings/billing/portal) on your Stripe
      account, customers will use it to manage their subscriptions.
    </Callout>

    <ImageZoom src="https://static.keyforge.dev/docs-stripe-integration-connect-subscription.png" alt="Connect Stripe subscription" width={1920} height={1080} unoptimized />
  </Step>

  <Step>
    ### You're done! 🎉

    It's as simple as that! Create a payment link for your product and start selling. When a customer subscribes to the product, a license will be automatically created on Keyforge and they will get emailed the license key.
  </Step>
</Steps>

## Learn more

### License expiration & renewals

Licenses are **timed** and expire if the subscription isn't renewed. The expiration date updates automatically when an invoice is paid.

### Subscription management

#### Changing plans

If customers switch plans in the Stripe billing portal, ensure each plan has a connected corresponding Keyforge product. The license will be updated accordingly.

#### Plan quantity

For plans with a quantity greater than 1, the license **maximum active devices** will be multiplied by the quantity.

#### Disconnecting & unlinking

* Removing a connected Stripe subscription won't stop license updates on renewal.
* To **unlink a subscription** from a license, do so on the licenses page, but note that the license will no longer update on renewal, and the customer may continue paying.

### Free Trials

You can offer free trials by setting them up in Stripe. No change is needed on Keyforge.


# Activate license (/api-reference/licenses/activate-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Activate a license for a device.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses/activate","method":"post"}]} webhooks={[]} hasHead={false} />


# Create license (/api-reference/licenses/create-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Create a new license.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses","method":"post"}]} webhooks={[]} hasHead={false} />


# Delete license (/api-reference/licenses/delete-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Delete an existing license.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses","method":"delete"}]} webhooks={[]} hasHead={false} />


# Get license (/api-reference/licenses/get-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Retrieve information about a license.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses","method":"get"}]} webhooks={[]} hasHead={false} />


# Remove device (/api-reference/licenses/remove-device)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Remove a specific active device from a license.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses/devices/{deviceId}/remove","method":"post"}]} webhooks={[]} hasHead={false} />


# Reset devices (/api-reference/licenses/reset-devices)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Reset all active devices for a license.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses/devices/reset","method":"post"}]} webhooks={[]} hasHead={false} />


# Update license (/api-reference/licenses/update-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Update an existing license.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses","method":"patch"}]} webhooks={[]} hasHead={false} />


# Validate license (/api-reference/licenses/validate-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Verify if a license is valid.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/licenses/validate","method":"post"}]} webhooks={[]} hasHead={false} />


# Create private session (/api-reference/portal/create-private-session)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Create a private portal session showing only your Keyforge products.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/portal/sessions/private","method":"post"}]} webhooks={[]} hasHead={false} />


# Create product (/api-reference/products/create-product)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Create a new product.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/products","method":"post"}]} webhooks={[]} hasHead={false} />


# Delete product (/api-reference/products/delete-product)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Delete an existing product.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/products/{productId}","method":"delete"}]} webhooks={[]} hasHead={false} />


# Get product (/api-reference/products/get-product)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Retrieve information about a product.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/products/{productId}","method":"get"}]} webhooks={[]} hasHead={false} />


# List products (/api-reference/products/list-products)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Retrieve a list of products.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/products","method":"get"}]} webhooks={[]} hasHead={false} />


# Update product (/api-reference/products/update-product)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Update an existing product.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/products/{productId}","method":"patch"}]} webhooks={[]} hasHead={false} />


# Activate license (/api-reference/public/public-activate-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Activate a license for a device.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/public/licenses/activate","method":"post"}]} webhooks={[]} hasHead={false} />


# Get license token (/api-reference/public/public-license-token)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get a new signed token for a license. License tokens need to be configured for the product to use this endpoint.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/public/licenses/token","method":"post"}]} webhooks={[]} hasHead={false} />


# Get license token public key (/api-reference/public/public-product-license-token-public-key)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get the public key JWK of a product for verifying license tokens. This endpoint is only available if the product supports license tokens and exposes its public key.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/public/products/{productId}/license-token/public-key","method":"get"}]} webhooks={[]} hasHead={false} />


# Validate license (/api-reference/public/public-validate-license)



{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Verify if a license is valid.

<APIPage document={"./openapi/v1.yaml"} operations={[{"path":"/api/v1/public/licenses/validate","method":"post"}]} webhooks={[]} hasHead={false} />