Steganography Online Codec Web API SDK Documentation

"use strict";

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example shows how to hide an encrypted secret message in an image file.
 *
 * Version      : v1.00
 * Language     : JavaScript
 * Author       : Bartosz Wójcik (original example)
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';

// create Steganography Online Codec class instance (we are using our activation key)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// encode a hidden message (encrypted with your password) within an image file
(async () => {

	const inputFile = 'input_file.jpg';
	const secretMessage = 'Secret message';
	const password = 'Pa$$word';
	const outputFile = 'output_file_with_hidden_secret_message.png';

	try {
		const result = await mySteganographyOnlineCodec.encode(inputFile, secretMessage, password, outputFile);

		// result object holds the encoding results as well as other information
		console.log('Secret message encoded and saved to the output PNG file.');
	} catch (err) {
		console.error('Encoding failed:', err.error_message || err.message || String(err));
	}
})();

// Example: hide an encrypted secret message in an image via the Web API.

use steganography_online_codec::SteganographyOnlineCodec;

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    let input_file = "input_file.jpg";
    let secret_message = "Secret message";
    let password = "Pa$$word";
    let output_file = "output_file_with_hidden_secret_message.png";

    match my_steganography_online_codec
        .encode(input_file, secret_message, password, output_file)
        .await
    {
        Ok(_result) => {
            println!("Secret messaged encoded and saved to the output PNG file.");
        }
        Err(err) => {
            eprintln!("Encoding failed: {}", err.error_message());
        }
    }
}

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example shows how to hide an encrypted secret message in an image file.
 *
 * Version      : v1.00
 * Language     : C#
 * Author       : Bartosz Wójcik (original example)
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;
// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// create Steganography Online Codec class instance (activation key placeholder)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// encode a hidden message (encrypted with your password) within an image file
const string InputFile = "input_file.jpg";
const string SecretMessage = "Secret message";
const string Password = "Pa$$word";
const string OutputFile = "output_file_with_hidden_secret_message.png";

try
{
	await codec.EncodeAsync(InputFile, SecretMessage, Password, OutputFile).ConfigureAwait(false);

	// EncodeResult exposes license telemetry when available.
	Console.WriteLine("Secret messaged encoded and saved to the output PNG file.");
}
catch (SteganographyApiException err)
{
	Console.Error.WriteLine("Encoding failed: " + (!string.IsNullOrEmpty(err.Message)
		? err.Message
		: $"Error code {err.Error}"));
}

"use strict";

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example, we will see how to extract a previously encrypted & hidden
 * secret message from an image file.
 *
 * Version      : v1.00
 * Language     : JavaScript
 * Author       : Bartosz Wójcik
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
 /*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';

// create Steganography Online Codec class instance (we are using our activation key)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// extract a hidden message from the previously encoded image file
(async () => {
	// full version image size limit is set to 10 MB (demo 50 kB max)
	// supported image format is PNG and only PNG!
	const inputFilePath = 'output_file_with_hidden_secret_message.png';

	// full version password length is 128 characters max (demo 8 chars max)
	const password = 'Pa$$word';

	try {
		// extract a hidden message from the image (PNG files only)
		const result = await mySteganographyOnlineCodec.decode(inputFilePath, password);

		// result object holds the decoding results as well as other information
		console.log(`You are running in ${result.license?.activationStatus ? 'full' : 'demo'} version`);

		console.log(`Secret message is "${result.message}"`);

		if (result.license && result.license.usagesCount !== undefined) {
			console.log(`Remaining number of usage credits - ${result.license.usagesCount}`);
		}
	} catch (err) {
		switch (err.error) {
			case Errors.INVALID_INPUT:
				console.log(`Invalid input file ${inputFilePath} or file doesn't exist`);
				break;
			case Errors.IMAGE_TOO_BIG:
				console.log(`Image file is too big, current limit is set to ${err.raw?.limits?.maxFileSize ?? 'unknown'}`);
				break;
			case Errors.LIMIT_MESSAGE:
				console.log(`Extracted message is too long, current limit is set to ${err.raw?.limits?.maxMessageLen ?? 'unknown'}`);
				break;
			case Errors.LIMIT_PASSWORD:
				console.log(`Password is too long, current limit is set to ${err.raw?.limits?.maxPasswordLen ?? 'unknown'}`);
				break;
			case Errors.INVALID_PASSWORD:
				console.log('Invalid password');
				break;
			default:
				console.log(`An error occurred: ${err.error_message ?? String(err)}`);
		}
	}
})();

// Example: decode (extract) a hidden message from a PNG.

use steganography_online_codec::{errors, SteganographyOnlineCodec};

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    // full version image size limit is set to 10 MB (demo 50 kB max)
    // supported image format is PNG and only PNG!
    let input_file_path = "output_file_with_hidden_secret_message.png";

    // full version password length is 128 characters max (demo 8 chars max)
    let password = "Pa$$word";

    match my_steganography_online_codec
        .decode(input_file_path, password)
        .await
    {
        Ok(result) => {
            let full = result
                .license
                .as_ref()
                .and_then(|l| l.activation_status)
                .unwrap_or(false);
            println!(
                "You are running in {} version",
                if full { "full" } else { "demo" }
            );

            let msg = result.message.as_deref().unwrap_or("");
            println!("Secret message is \"{msg}\"");

            if let Some(ref lic) = result.license {
                if let Some(c) = lic.usages_count {
                    println!("Remaining number of usage credits - {c}");
                }
            }
        }
        Err(err) => match err.code() {
            errors::INVALID_INPUT => {
                println!(
                    "Invalid input file {} or file doesn't exist",
                    input_file_path
                );
            }
            errors::IMAGE_TOO_BIG => {
                let lim = err
                    .raw()
                    .and_then(|j| j.get("limits"))
                    .and_then(|l| l.get("maxFileSize"))
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "unknown".to_string());
                println!("Image file is too big, current limit is set to {lim}");
            }
            errors::LIMIT_MESSAGE => {
                let lim = err
                    .raw()
                    .and_then(|j| j.get("limits"))
                    .and_then(|l| l.get("maxMessageLen"))
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "unknown".to_string());
                println!(
                    "Extracted message is too long, current limit is set to {lim}"
                );
            }
            errors::LIMIT_PASSWORD => {
                let lim = err
                    .raw()
                    .and_then(|j| j.get("limits"))
                    .and_then(|l| l.get("maxPasswordLen"))
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "unknown".to_string());
                println!("Password is too long, current limit is set to {lim}");
            }
            errors::INVALID_PASSWORD => {
                println!("Invalid password");
            }
            _ => {
                println!("An error occurred: {}", err.error_message());
            }
        },
    }
}

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example, we will see how to extract a previously encrypted & hidden
 * secret message from an image file.
 *
 * Version      : v1.00
 * Language     : C#
 * Author       : Bartosz Wójcik
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using System.Text.Json;
using PELock;

// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// create Steganography Online Codec class instance (activation key placeholder)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// extract a hidden message from the previously encoded image file
// full version image size limit is set to 10 MB (demo 50 kB max)
// supported image format is PNG and only PNG!
string inputFilePath = "output_file_with_hidden_secret_message.png";

// full version password length is 128 characters max (demo 8 chars max)
const string Password = "Pa$$word";

try
{
	// extract a hidden message from the image (PNG files only)
	DecodeResult result =
		await codec.DecodeAsync(inputFilePath, Password).ConfigureAwait(false);

	string runningVersion = result.License?.ActivationStatus == true ? "full" : "demo";

	Console.WriteLine($"You are running in {runningVersion} version");

	Console.WriteLine($"Secret message is \"{result.Message}\"");

	if (result.License?.UsagesCount.HasValue ?? false)
		Console.WriteLine($"Remaining number of usage credits - {result.License!.UsagesCount}");
}
catch (SteganographyApiException err)
{
	switch (err.Error)
	{
	case Errors.InvalidInput:
		Console.WriteLine($"Invalid input file {inputFilePath} or file doesn't exist");
		break;
	case Errors.ImageTooBig:
		Console.WriteLine($"Image file is too big, current limit is set to {ReadLimitDecode(err.Raw, "maxFileSize")}");
		break;
	case Errors.LimitMessage:
		Console.WriteLine($"Extracted message is too long, current limit is set to {ReadLimitDecode(err.Raw, "maxMessageLen")}");
		break;
	case Errors.LimitPassword:
		Console.WriteLine($"Password is too long, current limit is set to {ReadLimitDecode(err.Raw, "maxPasswordLen")}");
		break;
	case Errors.InvalidPassword:
		Console.WriteLine("Invalid password");
		break;
	default:
		Console.WriteLine($"An error occurred: {(string.IsNullOrEmpty(err.Message) ? $"API error code {err.Error}" : err.Message)}");
		break;
	}
}

static string ReadLimitDecode(JsonElement? payload, string key)
{
	if (payload.HasValue &&
		payload.Value.TryGetProperty("limits", out JsonElement limits) &&
		limits.TryGetProperty(key, out JsonElement probe) &&
		probe.ValueKind == JsonValueKind.Number &&
		probe.TryGetInt64(out long value))
	{
		return value.ToString();
	}

	return "unknown";
}

"use strict";

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example, we will see how to hide an encrypted message in an
 * image file using our codec.
 *
 * Version      : v1.00
 * Language     : JavaScript
 * Author       : Bartosz Wójcik
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
 /*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';


// create Steganography Online Codec class instance (we are using our activation key)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// encode a hidden message within the source image file
(async () => {
	// full version image size limit is set to 10 MB (demo 50 kB max)
	// supported image formats are PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (mail me for more)
	const inputFilePath = 'input_file.webp';

	// full version message size is unlimited (demo 16 chars max)
	const secretMessage = 'Secret message';

	// full version password length is 128 characters max (demo 8 chars max)
	const password = 'Pa$$word';

	// where to save encoded image with the secret message
	const outputFilePath = 'output_file_with_hidden_secret_message.png';

	try {
		// encode a hidden message (encrypted with your password) within an image file
		const result = await mySteganographyOnlineCodec.encode(inputFilePath, secretMessage, password, outputFilePath);

		// result object holds the encoding results as well as other information
		const versionType = result.license && result.license.activationStatus ? 'full' : 'demo';
		console.log(`You are running in ${versionType} version`);

		console.log(`Secret message encoded and saved to ${outputFilePath}`);
		if (result.license && result.license.usagesCount !== undefined) {
			console.log(`Remaining number of usage credits - ${result.license.usagesCount}`);
		}
	} catch (err) {
		const errorCode = err.error;

		switch (errorCode) {
			case Errors.INVALID_INPUT:
				console.log(`Invalid input file ${inputFilePath} or file doesn't exist`);
				break;
			case Errors.MESSAGE_TOO_LONG:
				console.log('Message is too long for the provided image file, use larger file');
				break;
			case Errors.IMAGE_TOO_BIG:
				console.log(`Image file is too big, current limit is set to ${err.raw?.limits?.maxFileSize ?? 'unknown'}`);
				break;
			case Errors.LIMIT_MESSAGE:
				console.log(`Message is too long, current limit is set to ${err.raw?.limits?.maxMessageLen ?? 'unknown'}`);
				break;
			case Errors.LIMIT_PASSWORD:
				console.log(`Password is too long, current limit is set to ${err.raw?.limits?.maxPasswordLen ?? 'unknown'}`);
				break;
			case Errors.INVALID_PASSWORD:
				console.log('Invalid password');
				break;
			default:
				console.log(`An error occurred: ${err.error_message ?? `Error code ${errorCode}`}`);
		}
	}
})();

// Example: encode with error-code handling (demo vs full limits).

use steganography_online_codec::{errors, SteganographyOnlineCodec};

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    // full version image size limit is set to 10 MB (demo 50 kB max)
    // supported image formats are PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (mail me for more)
    let input_file_path = "input_file.webp";

    // full version message size is unlimited (demo 16 chars max)
    let secret_message = "Secret message";

    // full version password length is 128 characters max (demo 8 chars max)
    let password = "Pa$$word";

    // where to save encoded image with the secret message
    let output_file_path = "output_file_with_hidden_secret_message.png";

    match my_steganography_online_codec
        .encode(
            input_file_path,
            secret_message,
            password,
            output_file_path,
        )
        .await
    {
        Ok(result) => {
            let version_type = result
                .license
                .as_ref()
                .and_then(|l| l.activation_status)
                .unwrap_or(false);
            println!(
                "You are running in {} version",
                if version_type { "full" } else { "demo" }
            );

            println!(
                "Secret messaged encoded and saved to {}",
                output_file_path
            );
            if let Some(ref lic) = result.license {
                if let Some(c) = lic.usages_count {
                    println!("Remaining number of usage credits - {c}");
                }
            }
        }
        Err(err) => {
            let error_code = err.code();
            match error_code {
                errors::INVALID_INPUT => {
                    println!(
                        "Invalid input file {} or file doesn't exist",
                        input_file_path
                    );
                }
                errors::MESSAGE_TOO_LONG => {
                    println!(
                        "Message is too long for the provided image file, use larger file"
                    );
                }
                errors::IMAGE_TOO_BIG => {
                    let lim = err
                        .raw()
                        .and_then(|j| j.get("limits"))
                        .and_then(|l| l.get("maxFileSize"))
                        .map(|v| v.to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    println!("Image file is too big, current limit is set to {lim}");
                }
                errors::LIMIT_MESSAGE => {
                    let lim = err
                        .raw()
                        .and_then(|j| j.get("limits"))
                        .and_then(|l| l.get("maxMessageLen"))
                        .map(|v| v.to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    println!("Message is too long, current limit is set to {lim}");
                }
                errors::LIMIT_PASSWORD => {
                    let lim = err
                        .raw()
                        .and_then(|j| j.get("limits"))
                        .and_then(|l| l.get("maxPasswordLen"))
                        .map(|v| v.to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    println!("Password is too long, current limit is set to {lim}");
                }
                errors::INVALID_PASSWORD => {
                    println!("Invalid password");
                }
                _ => {
                    println!("An error occurred: {}", err.error_message());
                }
            }
        }
    }
}

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example, we will see how to hide an encrypted message in an
 * image file using our codec.
 *
 * Version      : v1.00
 * Language     : C#
 * Author       : Bartosz Wójcik
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using System.Text.Json;
using PELock;

// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// create Steganography Online Codec class instance (activation key placeholder)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// encode a hidden message within the source image file
// full version image size limit is set to 10 MB (demo 50 kB max)
// supported image formats are PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (mail me for more)
string inputFilePath = "input_file.webp";

// full version message size is unlimited (demo 16 chars max)
const string SecretMessage = "Secret message";

// full version password length is 128 characters max (demo 8 chars max)
const string Password = "Pa$$word";

// where to save encoded image with the secret message
string outputFilePath = "output_file_with_hidden_secret_message.png";

try
{
	// encode a hidden message (encrypted with your password) within an image file
	EncodeResult result =
		await codec.EncodeAsync(inputFilePath, SecretMessage, Password, outputFilePath).ConfigureAwait(false);

	string versionType = result.License?.ActivationStatus == true ? "full" : "demo";
	Console.WriteLine($"You are running in {versionType} version");

	Console.WriteLine($"Secret messaged encoded and saved to {outputFilePath}");

	if (result.License?.UsagesCount.HasValue ?? false)
		Console.WriteLine($"Remaining number of usage credits - {result.License!.UsagesCount}");
}
catch (SteganographyApiException err)
{
	int errorCode = err.Error;

	switch (errorCode)
	{
	case Errors.InvalidInput:
		Console.WriteLine($"Invalid input file {inputFilePath} or file doesn't exist");
		break;
	case Errors.MessageTooLong:
		Console.WriteLine("Message is too long for the provided image file, use larger file");
		break;
	case Errors.ImageTooBig:
		Console.WriteLine($"Image file is too big, current limit is set to {ReadLimitLong(err.Raw, "maxFileSize")}");
		break;
	case Errors.LimitMessage:
		Console.WriteLine($"Message is too long, current limit is set to {ReadLimitLong(err.Raw, "maxMessageLen")}");
		break;
	case Errors.LimitPassword:
		Console.WriteLine($"Password is too long, current limit is set to {ReadLimitLong(err.Raw, "maxPasswordLen")}");
		break;
	case Errors.InvalidPassword:
		Console.WriteLine("Invalid password");
		break;
	default:
		Console.WriteLine($"An error occurred: {(!string.IsNullOrEmpty(err.Message) ? err.Message : $"Error code {errorCode}")}");
		break;
	}
}

static string ReadLimitLong(JsonElement? payload, string key)
{
	if (payload.HasValue &&
		payload.Value.TryGetProperty("limits", out JsonElement limits) &&
		limits.TryGetProperty(key, out JsonElement probe) &&
		probe.ValueKind == JsonValueKind.Number &&
		probe.TryGetInt64(out long value))
	{
		return value.ToString();
	}

	return "unknown";
}

"use strict";

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example we will verify our activation key status.
 *
 * Version      : v1.00
 * Language     : JavaScript
 * Author       : Bartosz Wójcik
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
 /*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';

// create Steganography Online Codec class instance (we are using our activation key)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// login to the service
(async () => {
	try {
		const result = await mySteganographyOnlineCodec.login();

		// result object holds the information about the license & current limits
		const versionType = result.license && result.license.activationStatus ? 'full' : 'demo';
		console.log(`You are running in ${versionType} version`);

		// information about the current license
		if (result.license && result.license.activationStatus) {
			console.log(`Registered for - ${result.license.userName}`);
			const licenseType = result.license.type === 0 ? 'personal' : 'company';
			console.log(`License type - ${licenseType}`);
			console.log(`Total number of purchased usage credits - ${result.license.usagesTotal}`);
			console.log(`Remaining number of usage credits - ${result.license.usagesCount}`);
		}

		// current limits (different for DEMO and FULL versions)
		if (result.limits) {
			console.log(`Max. password length - ${result.limits.maxPasswordLen}`);
			const msgLen = result.limits.maxMessageLen === -1 ? 'unlimited' : result.limits.maxMessageLen;
			console.log(`Max. message length - ${msgLen}`);
			console.log(`Max. input image file size - ${mySteganographyOnlineCodec.convert_size(result.limits.maxFileSize)}`);
		}
	} catch (err) {
		console.error(`Login failed: ${err.error_message || String(err)}`);
	}
})();

// Example: check license status and current API limits (`login`).

use steganography_online_codec::SteganographyOnlineCodec;

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    match my_steganography_online_codec.login().await {
        Ok(result) => {
            let version_type = result
                .license
                .as_ref()
                .and_then(|l| l.activation_status)
                .unwrap_or(false);
            println!(
                "You are running in {} version",
                if version_type { "full" } else { "demo" }
            );

            if let Some(ref lic) = result.license {
                if lic.activation_status.unwrap_or(false) {
                    if let Some(ref name) = lic.user_name {
                        println!("Registered for - {name}");
                    }
                    let license_type = if lic.license_type == Some(0) {
                        "personal"
                    } else {
                        "company"
                    };
                    println!("License type - {license_type}");
                    if let Some(t) = lic.usages_total {
                        println!("Total number of purchased usage credits - {t}");
                    }
                    if let Some(c) = lic.usages_count {
                        println!("Remaining number of usage credits - {c}");
                    }
                }
            }

            if let Some(ref limits) = result.limits {
                if let Some(m) = limits.max_password_len {
                    println!("Max. password length - {m}");
                }
                if let Some(ml) = limits.max_message_len {
                    let msg_len = if ml == -1 {
                        "unlimited".to_string()
                    } else {
                        ml.to_string()
                    };
                    println!("Max. message length - {msg_len}");
                }
                if let Some(fs) = limits.max_file_size {
                    println!(
                        "Max. input image file size - {}",
                        SteganographyOnlineCodec::convert_size(fs)
                    );
                }
            }
        }
        Err(err) => {
            eprintln!("Login failed: {}", err.error_message());
        }
    }
}

/******************************************************************************
 *
 * Steganography Online Codec WebApi interface usage example.
 *
 * In this example we will verify our activation key status.
 *
 * Version      : v1.00
 * Language     : C#
 * Author       : Bartosz Wójcik
 * Project      : https://www.pelock.com/products/steganography-online-codec
 * Homepage     : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// create Steganography Online Codec class instance (activation key placeholder)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// login to the service
try
{
	LoginResult result =
		await codec.LoginAsync().ConfigureAwait(false);

	string versionType =
		result.License?.ActivationStatus == true ? "full" : "demo";

	Console.WriteLine($"You are running in {versionType} version");

	if (result.License?.ActivationStatus == true)
	{
		Console.WriteLine($"Registered for - {result.License!.UserName}");
		string licenseType = result.License.Type == 0 ? "personal" : "company";
		Console.WriteLine($"License type - {licenseType}");
		Console.WriteLine($"Total number of purchased usage credits - {result.License.UsagesTotal}");
		Console.WriteLine($"Remaining number of usage credits - {result.License.UsagesCount}");
	}

	if (result.Limits != null)
	{
		Console.WriteLine($"Max. password length - {result.Limits.MaxPasswordLen}");
		string msgLen = result.Limits.MaxMessageLen == -1 ? "unlimited" : result.Limits.MaxMessageLen.ToString();
		Console.WriteLine($"Max. message length - {msgLen}");
		Console.WriteLine($"Max. input image file size - {codec.ConvertSize(result.Limits.MaxFileSize)}");
	}
}
catch (SteganographyApiException err)
{
	Console.Error.WriteLine("Login failed: " + (!string.IsNullOrEmpty(err.Message) ? err.Message : $"Error code {err.Error}"));
}