Licensing Last updated: 2026-09-24

ediFabric Native checks the license on parse, build, split, and merge. Copy the serial from Your account after you sign up for Community or buy a plan. The same serial covers ediFabric .NET, Native, and Cloud.

Register the machine once with install_license, then call the function for your plan before you translate. Buffers are UTF-8, pointer + length. The C signatures are in the Native introduction.

Which call to use

Plan	What works	Call this
Community	`set_serial` only. Online check on each operation. 250 operations per day. Non-production. 1 seat. Never expires.	`set_serial`
Developer	`set_serial` and `ensure_token`. `ensure_token` caches the result in the process for 1 day. `get_token` is not available (error 628). 3 seats.	`ensure_token`
Enterprise	`get_token` and `set_token`. Offline tokens last 30 days by default, or 90 or 180 days on request. Unlimited seats.	`set_token`

install_license(serial)               // once per machine, needs internet

set_serial(serial)                    // Community

ensure_token(serial, seconds)        // Developer: 1-day cache; pass seconds to refresh early

get_token(serial) → token             // Enterprise, on a host with internet
set_token(token)                      // Enterprise: per process start, no license call

One operation is one parse, generate, validate, or acknowledge call. The Community quota of 250 a day is shared across ediFabric .NET, Native, and Cloud. Past that, the call returns error 639. Developer and Enterprise allow up to 10,000 token requests per day across .NET and Native. If you exceed the rate, wait 60 seconds (error 636). A seat is one environment.

During an Enterprise trial, use ensure_token. Offline tokens are issued after purchase. Use of the product is subject to the EULA. Upgrading is a serial-key swap; then switch to the call in the table.

Community

install_license(serial)    // once per machine
set_serial(serial)         // each process start

Online check on each operation. The machine needs internet when it translates.
250 operations per day, one seat, non-production evaluation.
You may not redistribute the library or the model files.

Developer

For production use by an individual or a small team. ensure_token contacts the license server, then keeps the result in the process for one day. Pass seconds to refresh before that cache expires, so a later outage or a long batch keeps running.

install_license(serial)              // once per machine
ensure_token(serial, 3600)           // refresh if the cached token expires within 3600 seconds

3 seats. At the limit, a new environment takes the oldest lease from a previous day.
get_token returns error 628 on this plan.
You may process EDI in a product you operate, including other companies' files on hosts you run. Redistributing the library inside a product you sell requires the OEM rider on Enterprise.

Enterprise

Mint tokens on a machine that can reach the Authentication API, store them, and apply them with set_token wherever EDI runs. After set_token, translation runs offline. Keep a shared pool of unexpired tokens and hand them out to each process.

install_license(serial)          // once, on the host that mints tokens
get_token(serial) → token        // store it; refresh before it expires
set_token(token)                 // every process, including air-gapped hosts

Unlimited seats. The standard token lifetime is 30 days. 90 and 180 days are available on request.
Query get_token_expiration (UTC ticks; 0 means none) and refresh with get_token before the token expires. validate_token checks a token without caching it.
Perpetual is Enterprise rights bought once, excluding Cloud. The serial does not expire. Updates and support after the first year are optional maintenance.
OEM, for shipping the library inside a product you sell, is quoted on top of Enterprise.

License API

Entry point	Signature	Purpose
`install_license`	`int install_license(byte* serial, int len)`	Register this machine once. Needs internet.
`set_serial`	`int set_serial(byte* serial, int len)`	Community. Online check on each operation.
`ensure_token`	`int ensure_token(byte* serial, int len, int seconds)`	Developer. Cache a token in this process for 1 day. `seconds` is the early-refresh window.
`get_token`	`int get_token(byte* serial, int len, byte* out, int cap, int* outLen)`	Enterprise. Fetch a signed token. Grow the buffer and retry when the call returns 1.
`set_token`	`int set_token(byte* token, int len)`	Enterprise. Apply a token for this process. No license call.
`validate_token`	`int validate_token(byte* token, int len)`	Validate a token without caching it.
`get_token_expiration`	`int get_token_expiration(long* expUtc)`	Token expiry as UTC ticks. `0` means none.
`get_app_version`	`int get_app_version(int* version)`	Library application version.

0 is success. Error 635 means no serial or token was set. Error 628 means the serial is missing or incorrect, including get_token on a Developer license. Error 631 means the token expired. The full list is in the Native introduction.

Authentication API

install_license, set_serial, ensure_token, and get_token reach the Authentication API over HTTPS. set_token does not. Allow these hosts if you set firewall rules:

Primary

Host: api.edination.com
IP: 104.211.12.89
Port: 443

Secondary

Host: api.edifabric.com
IP: floating

The API runs on more than one server, shared between Microsoft Azure and Amazon AWS. EdiFabric calls Azure first. If that endpoint does not respond after the configured timeout and retries, it calls the backup on AWS.

If both endpoints are down, or no token can be acquired, contact support or support@edifabric.com. We will send a temporary token. Pass it to set_token so Native keeps running until the Authentication API is reachable again. We also publish that token on our X.

set_token(temporaryToken)