REST, not a black box
POST JSON to /api/v1/documents/outbound with a partnerId and documentTypeCode. You get back a documentId and status — no X12 in your codebase.
Developer Platform
EDI as a modern API. JSON in, X12 out.
Trade with retailers, payers, and logistics partners over plain HTTPS. Send JSON, get back validation, acknowledgements, and delivery status as webhooks — no VAN, no X12 in your codebase, no six-week integration.
REST APIMCP serverSigned webhooksTypeScript SDKX12 + EDIFACT
curl -X POST https://signaledi.com/api/v1/documents/outbound \
-H "Authorization: Bearer $SIGNALEDI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"partnerId": "your-partner-id",
"documentTypeCode": "850",
"payload": {
"purchaseOrderNumber": "PO-1042",
"shipTo": {
"id": "DC-01",
"name": "RetailMart DC 01"
},
"lines": [
{
"lineNumber": 1,
"sku": "SKU-100",
"quantity": 24,
"unitPrice": 12.5
}
]
}
}'Runs anywhere HTTPS works — serverless, edge, or long-running
Ships next to the app you already deploy
SignalEDI is plain REST and webhooks, so it runs anywhere your code does — serverless functions, edge routes, or a long-running service. If you can make an HTTPS request, you can do EDI.
Next.jsVercelNodePythonGoEdge / serverlessTypeScript SDK
API pricing
Free tier, then usage-based — pay per call
The API has a genuine free tier: 5,000 calls / month free every month with sandbox and production keys, then $0.0015 / call pay-as-you-go. No seats, no per-document fees, no credit card to start. (SMB subscription plans are separate — flat monthly tiers with a 30-day free trial.)
Free tier — 5,000 calls / monthThen $0.0015 / callNo credit card to start
One endpoint
One POST. Every language. A predictable response.
The same outbound contract in cURL, Node, Python, and Go. Send business fields; we handle the segments, qualifiers, and partner-specific envelope.
curl -X POST https://signaledi.com/api/v1/documents/outbound \
-H "Authorization: Bearer $SIGNALEDI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"partnerId": "your-partner-id",
"documentTypeCode": "850",
"payload": {
"purchaseOrderNumber": "PO-1042",
"shipTo": {
"id": "DC-01",
"name": "RetailMart DC 01"
},
"lines": [
{
"lineNumber": 1,
"sku": "SKU-100",
"quantity": 24,
"unitPrice": 12.5
}
]
}
}'{
"ok": true,
"data": {
"documentId": "doc_01HXYZ…",
"status": "queued"
}
}{
"ok": false,
"error": {
"code": "VALIDATION_FAILED",
"message": "partnerId is required",
"fields": [{ "path": "partnerId", "message": "required" }]
}
}Built for production
The primitives you expect from a real API
Signed webhooks
Every delivery is HMAC-SHA256 signed over timestamp.body and replay-protected. Verify in a few lines of Node or Python.
Sandbox & production keys
Build against sandbox keys, then promote to production once a partner is certified. Same contract, scoped credentials.
Validation before send
Field-level errors are mapped to each partner's rules and returned as JSON — catch a bad segment before it ever reaches the partner.
Normalized inbound JSON
Inbound X12 lands as clean, consistent JSON the moment it arrives — your app reads business fields, not loops and qualifiers.
Status & acknowledgements
997, 999, and 277 acknowledgements surface as JSON and webhook events, so engineering and operations share one lifecycle.
Build vs buy
Keep EDI logic out of your product backlog
Building EDI parsing in-house typically takes 3–6 months before your first production partner file — transaction-set parsing, partner envelopes, validation rules, acknowledgements, retry states, webhook signing, and audit history. SignalEDI exposes those primitives as REST, SDK, webhook, and MCP surfaces so your application can stay focused on business fields.
Webhooks
Signed, verifiable, replay-protected
Validation results, acknowledgements, and delivery status arrive as events. Each one is HMAC-SHA256 signed over timestamp.body — verify it in a handful of lines before you trust the payload.
import crypto from "node:crypto";
function verifySignalEdiWebhook(input: {
rawBody: string;
signatureHeader: string;
timestampHeader: string;
secret: string;
}): boolean {
const provided = input.signatureHeader.replace(/^sha256=/i, "").toLowerCase();
const expected = crypto
.createHmac("sha256", input.secret)
.update(`${input.timestampHeader}.${input.rawBody}`, "utf8")
.digest("hex");
// Use a timing-safe compare so signature checks do not leak partial matches.
return crypto.timingSafeEqual(Buffer.from(provided, "hex"), Buffer.from(expected, "hex"));
}MCP server
Use EDI as tools in Claude, Cursor & Windsurf
Give any MCP client the SignalEDI engine as tools — parse, validate, send, and inspect EDI right inside a conversation or agent loop. No EDI logic in your prompt, just a key.
- parse_edi — Raw X12/EDIFACT → structured JSON + validation summary.
- validate_edi — Validate an interchange against X12 structural rules.
- send_outbound_document — Serialize JSON to EDI and send to a partner (webhook-acked).
- list_transactions — List recent transactions, scoped to the key.
- get_transaction — Fetch one transaction with full lifecycle status.
Published as @signaledi/mcp-server — runs over npx, authed by your platform key. Same metered usage as the API.
{
"mcpServers": {
"signaledi": {
"command": "npx",
"args": ["-y", "@signaledi/mcp-server"],
"env": { "SIGNALEDI_API_KEY": "sk_live_…" }
}
}
}In your toolchain
SDK, docs, and guides — wherever you start
TypeScript SDK
Typed client that mirrors the REST API. Install with npm i @signaledi/sdk and call the same endpoints with full types.
SDK examples →
MCP server
Drop @signaledi/mcp-server into Claude, Cursor, or Windsurf and parse, validate, and send EDI as tools — same key, same metered usage. New to MCP? It's a protocol that lets AI assistants call your API as structured tools.
Set up MCP →
API reference
Authentication, endpoints, rate limits, and webhook payload schemas — documented to match the live API.
Read the docs →
Pricing & billing
5,000 calls / month free, then $0.0015 / call. Pay through us, or install through a marketplace that bills you and remits to us.
See pricing →
10-minute quickstart
Create a sandbox key, POST your first 850, and receive a 997 webhook — copy-paste samples in four languages.
Start the quickstart →
Task-oriented guides
Send an 850, parse an 856 ASN, verify signed webhooks, map JSON to X12, and run the go-live checklist.
Browse guides →
Pricing & billing
5,000 calls / month free, then $0.0015 / call
Usage-based — no seats, no per-document fees. Pay through us on Stripe, or install through a marketplace you already use and let it bill you and remit to us. Same API, SDK, and MCP server either way.
Come directly to us
Sign up, issue a scoped key in the developer console, and add a card. We meter your usage and bill you through Stripe — you hold the relationship with SignalEDI.
Install through a marketplace
Already build on Vercel, GitHub, or AWS? Add SignalEDI the same way you added your last integration. The marketplace bills you on the invoice you already pay and remits to us — one less vendor relationship to set up.
Three steps
From key to first transaction in minutes
- 01
Create an API key
Spin up sandbox credentials in the dashboard — no sales call, no onboarding gate.
- 02
POST a document
Send JSON to /api/v1/documents/outbound. We translate to X12 and validate against partner rules.
- 03
Subscribe to events
Receive validation results, acknowledgements, and delivery status as signed webhooks.
Explore
Docs, API integration, and free EDI tools
Start building
Make your first EDI call today
5,000 calls / month free, then $0.0015 / call. Minutes to your first API call — add billing only when you pass the free tier.