# How to Generate Multiple Unique License Keys at Once Using SunLicense

> Learn to generate multiple unique license keys at once with SunLicense. Simply pass the count parameter to the constructor for batch generation and receive an array of keys.

- Repository: [Mehmet Selcuk Batal/php-license-key-generator](https://github.com/msbatal/php-license-key-generator)
- Tags: how-to-guide
- Published: 2026-03-07

---

**Pass the `count` parameter to the `SunLicense` constructor to batch-generate any number of license keys, which returns an array when the count exceeds one or a string for a single key.**

The `msbatal/php-license-key-generator` repository provides a lightweight, self-contained PHP utility for creating product license keys. By leveraging the `SunLicense` class constructor parameters, you can generate multiple unique license keys at once without instantiating the class multiple times or writing custom loops.

## Configuring the Constructor for Batch Generation

The `SunLicense` class accepts a **`$count`** parameter in its constructor (defined in [[`SunLicense.php`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php)](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php) at lines 56–71) that dictates how many keys to produce in a single operation. This value is stored internally in the private `$keyCount` property alongside other configuration options like `$prefix`, `$template`, and `$case`.

When you instantiate the class, set the `count` argument to your desired batch size:

```php
$generator = new SunLicense(
    prefix: 'PRO',
    template: null,  // Uses default 'X9XX99-XX99-9X9X-99XX9X'
    case: 'upper',
    count: 10       // Generates 10 keys
);

```

The constructor signature stores these values for later use by the generation engine, making the class stateful for the specific batch operation.

## The generate() Method and Return Type Logic

The [`generate()`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php#L20-L33) method (lines 20–33 in [`SunLicense.php`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php)) handles the actual batch creation. It implements a `while` loop that repeatedly calls the private `license()` method until the internal `$keys` array reaches the size specified by `$keyCount`.

**Return type behavior:**
- If `$keyCount` equals **1**, the method returns a single string.
- If `$keyCount` is **greater than 1**, it returns an array of strings.

This adaptive return type eliminates the need for manual array handling when you only need one key, while still supporting bulk operations efficiently.

## Template Parsing in the license() Method

Behind the scenes, the private `license()` method (lines 79–96 in [`SunLicense.php`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php)) constructs each individual key by walking through the template string character by character:

- **`X`** or any alphabetic character → Random letter (uppercase or lowercase based on the `$case` setting)
- **`9`** or any digit → Random digit 0–9
- **Any other character** → A literal dash (`-`)

The optional `$prefix` is prepended to the templated segment before being added to the results array. Because `generate()` calls `license()` repeatedly in its internal loop, each key in a batch receives independent randomization.

## Practical Batch Generation Example

The following example demonstrates how to generate multiple unique license keys at once using the `count` parameter:

```php
<?php
require_once 'SunLicense.php';

// Configure for 5 keys
$generator = new SunLicense(
    prefix: 'PRO',
    template: null,
    case: 'upper',
    count: 5
);

$keys = $generator->generate();  // Returns array of 5 strings

foreach ($keys as $licenseKey) {
    echo $licenseKey . PHP_EOL;
}

```

For single-key generation, omit the count parameter or set it to 1:

```php
$singleKey = (new SunLicense())->generate();  // Returns string directly
echo $singleKey;

```

## Summary

- **Set the batch size** using the `count` parameter in the `SunLicense` constructor (lines 56–71).
- **Retrieve multiple keys** by calling `generate()`, which returns an array when count exceeds 1 (lines 20–33).
- **Template parsing** occurs in the private `license()` method, using `X` for letters, `9` for digits, and other characters as separators (lines 79–96).
- **Adaptive return types** mean you get a string for single keys and an array for batches, simplifying downstream code.

## Frequently Asked Questions

### What parameter controls how many keys SunLicense generates at once?

The **`count`** parameter (stored internally as `$keyCount`) passed to the class constructor determines the batch size. According to the source code in [`SunLicense.php`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php) lines 56–71, this value drives the `while` loop inside the `generate()` method.

### Does SunLicense return an array or string when generating multiple keys?

When the `count` value is greater than 1, the `generate()` method returns an **array** of license key strings. If `count` is 1 (or omitted), it returns a single **string** directly. This logic is implemented in lines 20–33 of [`SunLicense.php`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php).

### Can I use a custom template when generating batches of keys?

Yes. The `template` parameter accepts any string where `X` represents a random letter, `9` represents a random digit, and other characters become separators. You can pass a custom template to the constructor alongside the `count` parameter, and the `license()` method (lines 79–96) will apply this pattern to every key in the batch.

### Where is the batch generation logic implemented in the source code?

The batch generation logic resides in the `generate()` method at **lines 20–33** of [`SunLicense.php`](https://github.com/msbatal/php-license-key-generator/blob/main/SunLicense.php). This method contains a `while` loop that continues calling the private `license()` method until the internal `$keys` array contains the number of entries specified by `$keyCount`.