Query Licenses and Activations using Web API

It is possible to query license and activation information using the Software Potential Web API. 

License and Activation Query API

The following methods are available to submit license queries to Software Potential:

• GetLicenseById
• GetLicenseByActivationKey
• GetLicensesByFilter
• GetCountOfLicensesByFilter
• GetLicenseSummariesByFilter

To retrieve Activations use

• Get ActivationsByFilter

At present, activations can only be queried on an individual license basis. It is not possible to retrieve all activations in a Software Potential account or all activations for a given Product Version.
 

See the API documentation on LicenseManagement interface.

Pagination

License and activation queries are paginated returning a default 100 records per page, and there is currently no way to override this deffault.

Query Filters

License Filter

Query License by Product

To query license issued within a given date range for a given product:

1. Call GetProducts to retrieve ProductId 
2. Create a LicenseFilter and set the ProductId property.
3. Call GetLicensesByFilter with the LicenseFilter

The following code snippet retrieves licenses issued in a given date range (StartDate, endDate) for a given product (productId):

....
LicenseFilter filter = new LicenseFilter();
filter.ProductId = productId;
filter.IssueDateRange = new DateRange();
filter.IssueDateRange.Start = startDate;
filter.IssueDateRange.End = endDate;
// Fetch all licenses across multiple pages
int currentPage = 0;
List<License> allLicenses = new List<License>();

while (currentPage >= 0)
{
    var result = service.GetLicensesByFilterPaginated(filter, options, currentPage);
    allLicenses.AddRange(result.Licenses);
    currentPage = result.NextPageIndex;
}

// Or using HasMorePages:
var pagedResult = service.GetLicensesByFilterPaginated(filter, options, 0);
while (pagedResult.HasMorePages)
{
    allLicenses.AddRange(pagedResult.Licenses);
    pagedResult = service.GetLicensesByFilterPaginated(filter, options, pagedResult.NextPageIndex);
}
.....

.....
/// <summary>
/// Retrieves a single page of licenses matching the specified filter
/// </summary>
/// <param name="filter">License filter criteria (date ranges, product ID, etc.)</param>
/// <param name="options">Retrieval options (Basic, LicenseInfo, etc.)</param>
/// <param name="pageIndex">Current page index (use 0 for first page)</param>
/// <returns>Paged result containing licenses and pagination information</returns>
public PagedLicenseResult GetLicensesByFilterPaginated( LicenseFilter filter, LicenseRetrievalOptions options, int pageIndex )
{
    return _api.Execute( client =>
    {
        var request = new GetLicensesByFilterRequest( filter, options, pageIndex );
        var response = client.GetLicensesByFilter( request );
        
        return new PagedLicenseResult
        {
            Licenses = response.GetLicensesByFilterResult.ToList(),
            NextPageIndex = response.pageIndex
        };
    } );
}

You will need to implement the appropriate pagination logic in your application code.

It is also to simplify pagination when retrieve all licenses for a product as follows:

/// <summary>
/// Retrieves all licenses matching the specified filter
/// </summary>
/// <param name="filter">License filter criteria (date ranges, product ID, etc.)</param>
/// <param name="options">Retrieval options (Basic, LicenseInfo, etc.)</param>
/// <returns>List of licenses matching the filter</returns>
public List<License> GetLicensesByFilter( LicenseFilter filter, LicenseRetrievalOptions options )
{
    return _api.Execute( client =>
    {
        List<License> licenses = new List<License>();
        int pageIndex = 0;
        var request = new GetLicensesByFilterRequest( filter, options, pageIndex );

        while( pageIndex >= 0 )
        {
            request.pageIndex = pageIndex;
            var response = client.GetLicensesByFilter( request );
            licenses.AddRange( response.GetLicensesByFilterResult );
            pageIndex = response.pageIndex;
        }

        return licenses;
    } );
}

Query Activations By License

The following code snippet retrieves a page of activations for a given license (licenseId):

.....
ActivationFilter filter = new ActivationFilter();
filter.LicenseId = licenseId;
var retreivealOption = ActivationRetrievealOption.Basic

// Fetch all activations across multiple pages
int currentPage = 0;
List<Activations> allActivations = new List<Activations>();

while (currentPage >= 0)
{
    var result = service.GetActivationsByFilterPaginated(filter, options, currentPage);
    allActivations.AddRange(result.Activations);
    currentPage = result.NextPageIndex;
}

// Or using HasMorePages:
var pagedResult = service.GetActivationsByFilterPaginated(filter, options, 0);
while (pagedResult.HasMorePages)
{
    allActivations.AddRange(pagedResult.Activations);
    pagedResult = service.GetActivationsByFilterPaginated(filter, options, pagedResult.NextPageIndex);
}
....

....
/// <summary>
/// Retrieves a single page of activations matching the specified filter
/// </summary>
/// <param name="filter">Activation filter criteria (license ID, etc.)</param>
/// <param name="options">Retrieval options (Basic, etc.)</param>
/// <param name="pageIndex">Current page index (use 0 for first page)</param>
/// <returns>Paged result containing activations and pagination information</returns>
public PagedActivationResult GetActivationsByFilterPaginated( ActivationFilter filter, ActivationRetrievalOptions options, int pageIndex )
{
    return _api.Execute( client =>
    {
        var request = new GetActivationsByFilterRequest( filter, options, pageIndex );
        var response = client.GetActivationsByFilter( request );
        
        return new PagedActivationResult
        {
            Activations = response.GetActivationsByFilterResult.ToList(),
            NextPageIndex = response.pageIndex
        };
    } );
}