Trial & paid tiers

veriCue licensing is fully offline. A license is an RSA-signed JSON key file that the Runtime library verifies against an embedded public key - no account, no activation server, no network calls. Your application under test never phones home.

Plans

Plan	Sessions	Model	Support	Price
Trial	1	local trial	limited e-mail support	EUR 0 / 30 days
Professional	3	organization license (signed key file)	first response within 2 business days	EUR 349/quarter or EUR 990/year
Enterprise	5	floating, self-hosted	1 business day	from EUR 2,900/year
Enterprise Plus	custom	floating + optional HA	dedicated support	from EUR 6,900/year

All paid tiers include the same core automation protocol and product capabilities. Plans differ primarily in licensing model, number of concurrent automation sessions, support level and enterprise deployment options.

All prices are net (excl. VAT). Enterprise and Enterprise Plus use a self-hosted floating license server and can add further capacity at EUR 450/year per additional concurrent automation session. See the full price list, including the Compatibility Assessment, the Implementation Sprint and the Launch Bundle, at vericue.dev/pricing, or contact sales@vericue.dev for a quote.

What is a concurrent automation session?

One concurrent automation session is one active test-client connection to a veriCue server instance. The number of developers who can write or maintain test code is not limited by the license.

The server accepts new connections while active connections < licensed sessions; the connection that exceeds the limit is refused with error 1009 license_session_limit_reached (the error identifier predates the current terminology and is kept stable for compatibility).

Disconnecting frees the session, but not instantaneously: the slot is given back when the server's event loop processes the disconnect, a moment after your client closes its socket. Ending one test process and immediately starting the next can therefore land in that window and be refused - on a trial's single session, reliably so.

You do not have to handle this. The Python, C++ and C# clients wait out a connect-time 1009 for a few seconds with a short backoff, so a sequential workflow simply works. The wait is bounded: a limit that is genuinely occupied still fails, promptly, with the server's own message. That message distinguishes the two cases where the server can tell them apart, so a 1009 you actually see means the sessions are in use rather than closing.

Connections count the same on either transport: a server listening on both a local IPC endpoint and a TCP port enforces one shared budget, not one per transport.

The Professional tier is an organization license: the signed key file is issued to your organization and is not technically locked to a specific machine. The session limit is what the server enforces.

Trial

If you never call setLicenseFile() (or setLicenseServer()), the server starts in trial mode automatically:

• 30 days, counted from the first run on that machine (a marker file is stored in the per-user data directory, e.g. ~/.local/share/vericue/.vericue_trial; override the location with the VERICUE_TRIAL_DIR environment variable for containers or read-only homes).
• 1 concurrent automation session - one client connection at a time.
• Full protocol, no command restrictions.
• Documentation and the Quick Start guides. No credit card, no sales contact, no key to request - the packages on https://dl.vericue.dev/ are public. Step-by-step: vericue.dev/start.

When the trial expires, the server keeps running but refuses every command except handshake, ping, and version, returning error 1012 trial_expired. Your application is unaffected - only the automation interface is gated.

There are three ways to evaluate veriCue:

• Self-service trial - the keyless mode described above: 30 days, 1 session, Quick Start docs, no implementation support. Start any time, no credit card, no contact required.
• Assisted evaluation - a signed trial key issued for your organization (contact sales@vericue.dev; keys are issued manually, typically within one business day). Choose this when you want a longer or organization-wide evaluation, or help confirming the integration in your real project.
• Compatibility Assessment - a paid evaluation service (EUR 900 one-time) for teams with real technical uncertainty: custom-painted controls, an unusual environment, or one critical GUI/QML scenario that has to be proven first. Covers 1 Qt application, 1 agreed environment, 1 critical GUI/QML scenario and a key compatibility-risk review, and ends with a short compatibility memo listing confirmed items, unconfirmed items and blockers, and a recommended next step. It reports what was verified inside the agreed scope and does not guarantee compatibility beyond it. See vericue.dev/pricing.

In both cases the trial support scope is the same and bounded: at most one 30-60 minute onboarding session, confirmation that the integration works, and a review of the first test you write yourself. Tests built for you, CI integration, custom development, debugging your whole application and unlimited support are not part of any trial - those are the paid Implementation Sprint and Launch Bundle listed on vericue.dev/pricing.

The license key

A key is a small JSON document signed with RSA-SHA256:

{
  "license": {
    "id": "VQT-2026-0042",
    "company": "Acme GmbH",
    "tier": "enterprise",
    "sessions": 10,
    "issued": "2026-07-01",
    "expiry": "2027-07-01"
  },
  "signature": "base64..."
}

The payload field for the licensed concurrent-session count is sessions; seats is accepted as a legacy alias so previously issued keys keep working unchanged.

Load it in your application under test:

vericue::VeriCueServer server(&window);
server.setLicenseFile("/etc/acme/vericue-license.json");
server.startLocal();     // or server.start(4242) for TCP

Call setLicenseFile() before the first start()/startLocal(); licensing is resolved once per run and a later change is ignored with a warning. Serving both transports from one server still consumes one session budget, not two.

The signature is verified offline against the public key compiled into libvericue-server. A tampered or unsigned key is rejected (the server falls back to trial mode and logs a warning).

Support scope

The support times above are first-response targets, not resolution guarantees. Support covers veriCue itself - installation, integration, protocol usage, client libraries, and licensing - not debugging your whole application. We will help you determine whether a problem sits in veriCue or in the application under test, but fixing application-side issues remains your team's work.

Renewal

Renewing issues a new key file - nothing changes in your integration:

1. Email sales@vericue.dev and we issue the renewed key.
2. Replace the file on disk.
3. Restart the application under test (the key is read once at startup).

Expiry

An expired license - trial or paid - gates the automation interface the same way: every command except handshake, ping, and version is refused, with 1012 trial_expired for trials and 1010 license_expired for paid keys. There is no remote kill switch; expiry is determined solely by the date inside the signed key.

Licensing error codes

Code	Name	When
1009	license_session_limit_reached	Connection exceeds the licensed concurrent-session count
1010	license_expired	Paid license past its expiry date
1011	license_invalid	Signature invalid or malformed key
1012	trial_expired	30-day trial finished

See the full error code reference.