Developer Platform

The EDI API that speaks MCP.

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.

Start free trialRead the docs →
REST APIMCP serverSigned webhooksTypeScript SDKX12 + EDIFACT
parse-response.json
{
  "documentType": "850",
  "status": "parsed",
  "purchaseOrder": "PO-DEMO-001",
  "buyer": "SYNTH BUYER LLC",
  "lineItems": [
    { "quantity": 12, "uom": "EA", "unitPrice": 19.99, "sku": "SKU-DEMO-100" }
  ]
}
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
Full API pricing →SMB plan pricing →
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.

send-850.sh
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
      }
    ]
  }
}'
202 Accepted
{
  "ok": true,
  "data": {
    "documentId": "doc_01HXYZ…",
    "status": "queued"
  }
}
400 Validation error
{
  "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

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.

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.

Verify signed webhooks →Webhook payload reference →
verify-webhook.ts
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. Run without a key in demo mode (parse/validate/generate only), then add a platform key for send and partner flows.

  • parse_edi ΓÇö Raw X12/EDIFACT → structured JSON + validation summary.
  • validate_edi ΓÇö Validate an interchange against X12 structural rules.
  • generate_test_document ΓÇö Synthetic 850/810/856/837 samples (demo mode).
  • explain_edi_error ΓÇö Local dictionary lookup for ack/validation errors.
  • lookup_x12 ΓÇö Search segment and acknowledgement reference.
  • 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.
  • quickbooks_status ΓÇö QBO connection status for your workspace (no tokens returned).
  • quickbooks_sync_to_qbo ΓÇö Push EDI transactions into QuickBooks (810→Invoice, 850→Bill).
  • quickbooks_export_to_edi ΓÇö Pull QBO entities and emit outbound EDI to a partner.
  • quickbooks_list_entities ΓÇö List QBO Invoice, PO, Customer, Vendor, or Item rows.
  • quickbooks_disconnect ΓÇö Revoke QBO OAuth and remove the workspace connection.
  • list_partner_kits ΓÇö List packaged API kits (retail, healthcare, quickstart).
  • get_partner_kit ΓÇö Fetch one kit by id (endpoints, webhooks, sample payloads).
  • validate_x12_structure ΓÇö Alias for validate_edi — spec-facing discovery name.
  • parse_segments ΓÇö Alias for parse_edi — spec-facing discovery name.
  • lookup_element_definition ΓÇö Alias for lookup_x12 — search by element or segment.

Published as @signaledi/mcp-server ΓÇö runs over npx, authed by your platform key. Same metered usage as the API.

npm version @signaledi/mcp-serverListed in the MCP Registry
Install in CursorOpen Cursor installer
Claude Code CLIclaude mcp add signaledi -- npx -y @signaledi/mcp-server
Config JSON{ "mcpServers": { "signaledi": { "command": "npx", "args": [ "-y", "@signaledi/mcp-server" ], "env": { "SIGNALEDI_API_KEY": "" } } } }
Create sandbox key →MCP details →
.mcp.json
{
  "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.

SignalEDI · Stripe

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.

SignalEDI · Stripe for Vercel Connectable

Install through a marketplace

Already build on Vercel or GitHub? Add SignalEDI through the supported integration flow. Vercel Connectable installs use SignalEDI direct billing through Stripe; the current GitHub App is free. Native marketplace billing is not enabled.

Full pricing, plans & channels →
Three steps

From key to first transaction in minutes

  1. 01

    Create an API key

    Spin up sandbox credentials in the dashboard ΓÇö no sales call, no onboarding gate.

  2. 02

    POST a document

    Send JSON to /api/v1/documents/outbound. We translate to X12 and validate against partner rules.

  3. 03

    Subscribe to events

    Receive validation results, acknowledgements, and delivery status as signed webhooks.

Explore

Docs, API integration, and free EDI tools

Documentation →EDI API integration →Free EDI validator →
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.

Start free trialCreate API key →