One self-contained library that translates, validates, acknowledges and rebuilds X12 - at native speed

Everything you need to work with X12 and HIPAA files, in a single library file you ship next to your own binary, and it is included in every plan.
Native performance

Compiled to native code with zero-copy UTF-8 buffers and streaming split/merge for high-throughput EDI processing.

Zero dependencies

A single self-contained shared library per platform. Copy that one file to the target machine and call it.

EDI to JSON and back

Translate between EDI data and structured JSON: a whole X12 interchange to JSON in one call with parse, and back again with build.

Streaming split & merge

Process one transaction set or segment at a time with flat, low memory use - ideal for very large interchange files.

Built-in validation

Validate transaction sets with configurable SNIP levels, regex, date/time formats, and error limits, for a detailed report.

Acknowledgments

Automatically generate 999, 997, and TA1 acknowledgments from validated interchanges in a single operation mode.

Translate EDI to JSON in a few lines

The official bindings wrap the C ABI, so buffer growth and error codes are handled for you. Each tab uses a real binding you can clone.
import json
import edifabric_x12 as ef

serial = "YOUR_SERIAL_KEY"
ef.load_library()
ef.set_serial(serial)
ef.set_map(json.dumps({"default": serial, "maps": {}}))

edi = open("837P_Claim.txt", "rb").read()
output, offset = ef.parse(edi, ef.ParseMode.JSON_VALIDATE)
transactions = output[:offset]
report = json.loads(output[offset:])
print(report["errors_count"])
using EdiFabric.Native.X12;

const string serial = "YOUR_SERIAL_KEY";
EdiFabricX12.Load();
EdiFabricX12.SetSerial(serial);
EdiFabricX12.SetMap($$"""{"default": "{{serial}}", "maps": {}}""");

var edi = File.ReadAllBytes("837P_Claim.txt");
var result = EdiFabricX12.Parse(edi, ParseMode.JsonValidate);
Console.WriteLine(result.Transactions);
Console.WriteLine(result.Report);
import com.edifabric.nativex12.EdiFabricX12;
import com.edifabric.nativex12.ParseMode;
import com.edifabric.nativex12.ParseResult;

String serial = "YOUR_SERIAL_KEY";
EdiFabricX12.loadLibrary();
EdiFabricX12.setSerial(serial);
EdiFabricX12.setMap("{\"default\":\"" + serial + "\",\"maps\":{}}");

String edi = Files.readString(Path.of("837P_Claim.txt"));
ParseResult result = EdiFabricX12.parse(edi, ParseMode.JSON_VALIDATE);
System.out.println(result.getTransactions());
System.out.println(result.getReport());
#include "edifabric_x12.h"

const char *serial = "YOUR_SERIAL_KEY";
ef_parse_result result;

if (ef_load_library(NULL) != 0)
    return 1;
ef_set_serial(serial);
ef_set_map("{\"default\":\"YOUR_SERIAL_KEY\",\"maps\":{}}");

char *edi = read_file("837P_Claim.txt", NULL);   /* helper in example_all_functions.c */
if (ef_parse(edi, EF_PARSE_JSON_VALIDATE, NULL, &result) == 0) {
    /* transactions = output[0 .. offset), report = output[offset .. length) */
    fwrite(result.output.data, 1, (size_t)result.output.length, stdout);
    ef_free(result.output.data);
}

Official bindings for your language

Thin, idiomatic wrappers over the same C entry points, with the foreign function interface (FFI) code already written. Clone one, point it at the library file, and start translating.
Python

A ctypes wrapper for Python that handles the grow-and-retry buffer for you.

View on GitHub
Java

JNA bindings for Java that map the native entry points to plain Java methods.

View on GitHub
C# and .NET

P/Invoke bindings that call the native library from C# and other .NET languages.

View on GitHub
C and C++

The reference header and examples that define the ABI every other binding wraps.

View on GitHub

Working in Rust, Go, Node.js or something else? They all call the same handful of C entry points, so the C bindings document contains everything you need. Tell us which language you are on and we will help you wire it up.


ediFabric Native comes with every plan

Every plan includes ediFabric .NET, ediFabric Native and ediFabric Cloud. Choose Native when a C FFI suits your stack; the price is the same whichever product you use.
Included in every plan
Free forever to start

Community costs nothing and never expires, giving you unlimited operations for the first 14 days, then 250 a day, and three leased seats for non-production work. Need more time? Ask support to extend the unlimited period. Developer and Enterprise lift the quota, Enterprise lifts the seat count, and all three include the same library.

X12 and HIPAA today
More standards to follow

Native is the newest of the three and covers X12 and HIPAA, with the remaining standards being released one at a time. If you need EDIFACT, HL7, NCPDP or flat files right now, use ediFabric .NET or ediFabric Cloud — your plan already includes them.

Your EDI data is safe
Data stays with you

Every operation runs inside your own process, on your own hardware. EDI data and PHI stay on your systems, so Native sits entirely within the controls you already have in place for HIPAA or SOC 2.

Start translating X12 today

Drop the library next to your binary, authorize it with your serial key, and translate your first interchange in minutes. The free Community plan needs no credit card, never expires, and has unlimited operations for the first 14 days.