One Core API does parse → validate → exchange for X12 and EDIFACT. Call it over REST or drop files on SFTP. You ship your roadmap; we carry the trading-partner complexity.
$ curl https://api.signaledi.com/v1/parse \
-H "Authorization: Bearer $SIGNALEDI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"content":"ISA*...complete X12 interchange...~IEA*...~"}'
{
"ok": true,
"validation": { "sourceFormat": "X12", "transactionSet": "850", "valid": true, "issues": [] },
"json": { "beginningSegment": { "poNumber": "4500" } }
}Buy direct, or provision through the marketplaces your customers already use
// one engine
The same engine that powers the SMB product, surfaced for your application. No business logic lives in your code.
Send raw X12 or EDIFACT inside the documented JSON request and receive a validated structured representation. Envelope, group, and segment errors come back as machine-readable diagnostics, not a stack trace.
Check envelope and structural compliance before a document ever reaches a trading partner. Catch framing failures in CI instead of in a chargeback; partner-specific profile rules are enforced at admission on /v1/documents/outbound.
Hand off to trading partners over the transport they require — API, AS2, or SFTP — and get acknowledgements (997/999/TA1) back as webhook events you can reconcile.
// quickstart
Same /v1/parse call from any stack. No SDK required — though we publish typed ones generated from the OpenAPI spec.
curl https://api.signaledi.com/v1/parse \
-H "Authorization: Bearer $SIGNALEDI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"content":"ISA*...complete X12 interchange...~IEA*...~"}'const res = await fetch(
"https://api.signaledi.com/v1/parse",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.SIGNALEDI_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ content: rawEdi }),
},
);
const { validation, json } = await res.json();import os, requests
res = requests.post(
"https://api.signaledi.com/v1/parse",
headers={
"Authorization": f"Bearer {os.environ['SIGNALEDI_API_KEY']}",
},
json={"content": raw_edi},
)
doc = res.json() # validation, structured json// reference
A small, predictable surface. Versioned, scoped by API key, metered per call.
/v1/parse/v1/validate/v1/documents/outbound/v1/documents/inbound/v1/document-types/v1/documents/:documentIdFull reference, schemas, and error codes in the API docs.
// two front doors
Pick the integration model that fits your stack. Many teams use both.
For teams that want code-level control
A versioned, predictable REST surface. Authenticate with a scoped API key, POST a payload, and handle a structured response. Webhooks push lifecycle and acknowledgement events back to you.
curl https://api.signaledi.com/v1/parse \
-H "Authorization: Bearer $SIGNALEDI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"content":"ISA*...complete X12 interchange...~IEA*...~"}'
# → 200 OK
# {
# "ok": true,
# "validation": { "sourceFormat": "X12", "transactionSet": "850", "valid": true, "issues": [] },
# "json": { /* structured parser output */ }
# }For systems that already speak files
Some platforms and ERPs only emit files. Drop X12/EDIFACT into a per-tenant SFTP inbox and we parse, validate, and exchange on a schedule — then write results and acknowledgements back to an outbox. No code change on your side.
sftp tenant_acme@sftp.signaledi.com
sftp> put purchase-order.edi /inbox/
# minutes later, in /outbox/:
# purchase-order.result.json # structured + validation
# purchase-order.997.edi # functional ack// for marketplaces & platforms
Run a marketplace, app store, or platform your customers build on? Offer EDI as an installable integration without building a compliance engine. We expose provisioning, scoped tokens, usage metering, and billing hooks so your users add EDI the same way they add any other integration — install, authorize, done.
// your billing, your way
The integration surface is identical. Only the billing and identity relationship changes.
Sign up, generate an API key, and start on a metered developer plan. You hold the billing relationship with SignalEDI and manage keys, usage, and invoices yourself.
Already buying through Vercel, AWS Marketplace, or Shopify? Provision SignalEDI from there and let that marketplace handle billing and identity. We resolve the marketplace token to a scoped account and meter usage back to it.
// how it works
Create an sk_lab_ key for customer-to-Signal development. Use an sk_cert_ key for partner testing; Production uses a separately authorized sk_live_ key and certified connection snapshot.
POST raw EDI to /v1/parse, submit a document through /v1/documents/outbound, or drop a file on SFTP.
Poll the document receipt and handle signed metadata-only lifecycle and acknowledgement webhooks.
Watch usage in the dashboard; billing flows through us or your marketplace. No per-document traps.
Get a scoped API key and an SFTP inbox in minutes. Bill through us or your marketplace.
© 2026 SignalEDI Inc. All rights reserved.