Why Licensing + Payments Matter

When you’re sharing an early prototype or trial - with investors, design partners, or internal reviewers - you need to (1) control access and (2) avoid throwaway work you’ll have to redo at launch.

Devolens lets you secure your PoC today and flip the same setup to paid plans later without any rebuilds.

‍

Options: Ad-hoc Sharing / DIY Gating vs. Devolens

Ad-hoc sharing (zip + NDA)

Fast, but no expirations, no feature gating, and high risk of leaks or untracked copies.

‍

DIY PoC gating

Hard-coded keys or quick scripts seem fine now, but they rarely survive to production (no revocation, no offline flow, no seat limits, no analytics).

‍

Devolens (third-party licensing)

‍

• Set trial duration, feature access, seat/device limits, or usage caps in minutes.
  ‍
• Offline and constrained environments supported (signed, time-limited tokens).
  ‍
• Convert the same integration to subscriptions, per-seat, per-module, or usage-based pricing at launch.
  ‍

Tip: Treat your PoC like a mini-product. You’ll move faster later if you start with production-ready entitlements now.

Implementation: License Verification

‍

1. Create a product with trial rules (duration, features, seats/usage).
   ‍
2. Add a lightweight check in your app/service that reads the license and turns features on/off, online or offline.
   ‍
3. Share safely with keys or offline files; revoke/extend as needed.
   ‍
4. Launch without rewrites: convert trials to paid by updating entitlements: same install, no new binaries.
   ‍

(Teams often report first integration in about an hour, depending on the codebase.)

Below is an example of how to verify a license in Python. You can access examples in other languages on this page.

‍

RSAPubKey = "enter the RSA Public key here"
auth = "access token with permission to access the activate method"

result = Key.activate(token=auth,\
                   rsa_pub_key=RSAPubKey,\
                   product_id=3349, \
                   key="ICVLD-VVSZR-ZTICT-YKGXL",\  
                   machine_code=Helpers.GetMachineCode(v=2))

if result[0] == None:
    # an error occurred or the key is invalid or it cannot be activated
    # (eg. the limit of activated devices was achieved)
    print("The license does not work: {0}".format(result[1]))
else:
    # everything went fine if we are here!
    print("The license is valid!")

Why Software Vendors Choose Devolens

‍

• Per-module licensing without multiple builds - unlock solvers, toolchains, and add-ons via entitlements.
  ‍
• Usage metering that fits your model - per run, API call, core-hour, or custom counters.
  ‍
• HPC/CI support - silent activation for build agents; time-boxed leases for cluster nodes.
  ‍
• Enterprise controls - role-based admin, audit logs, SSO-friendly flows, and optional on-prem components.
  ‍
• Payment flexibility - connect your processor or sell via POs and invoices.
  ‍

Common Scenarios We Cover

‍

• Simulation suites (FEA/CFD/EM): editions + solver modules + HPC packs.
  ‍
• SDKs & developer tooling: per-developer seats, per-app redistribution rights, request-based pricing.
  ‍
• Embedded/industrial: factory-floor activation, field-service rekeys, and offline compliance windows.
  ‍
• APIs for engineers: tiered plans with rate limits and overage credits.
  ‍

FAQ

Can we license per module or solver?

Yes - define modules as features and grant them per customer or plan.

Need offline for labs or factories?

Issue signed, time-limited tokens; set renewal windows that match your operations.

How do floating seats work for clusters?

Nodes check out a lease; idle timeouts recycle seats automatically.

Can we meter runs or core-hours?

Yes - send usage events via API or batch; bill on schedule or enforce soft/hard limits.

Do customers get self-service admin?

They can assign seats, move devices, download offline files, and view usage - within the limits you set.