Updated May 10, 2022

Track changes to the Stedi API and products. Follow us on Twitter to stay up-to-date.

April 25, 2022

JSONata Cheatsheet: JSONata playground now embedded in documentation

2 weeks ago we launched the JSONata playground, which allows users to experiment and learn the JSONata language using a free online tool. Now, with the JSONata embed functionality, we have replaced all of our JSONata examples in our documentation to use the same editor that is in the plaground.

See this in action with our JSONata cheatsheet.

JSONata cheatsheet

April 14th, 2022

JSONata Playground: Experiment writing JSONata experessions

JSONata is the JSON transformation language that powers Stedi's Mapping product. To help people learn JSONata, without the need to create a whole new mapping, we launched the JSONata Playgound: a free online tool that allows users to experiment and run JSONata expressions in the browser.

JSONata playground

March 24, 2022

Mappings: List indexes

If the list entries of your target document are expected to include a list index number, you can now access it by binding a positional variable to the Looping Context. You can read more about the positional variable binding in the JSONata docs. To learn more about list indexes and see examples, read our documentation here.

Mappings link indexes

Mappings: JSON Schema preview in Mappings UI

When you define a Source and Target JSON in the Mappings UI, these shapes are automatically converted to JSON Schema on the backend. Now, you can navigate to this JSON Schema directly in the Mappings UI. By using JSON Schema, you get a more precise description of the structure and validation constraints of your JSON documents.

JSON Schema preview in Mappings UI

Registry: collection of popular JSON Schemas

Registry is an open source repository of JSON Schemas for some of the web’s most popular APIs like Stripe, Shopify and Ramp. Schemas make it easy to turn a Stripe Invoice into a Ramp receipt, or a Shopify order into a Stripe checkout session. If you want to map any of these JSON Schemas to another JSON Schema, you can get started right away by using Stedi’s Mappings product. If you’d like us to add more JSON Schemas to the registry, please contact us!

March 10, 2022

EDI Core, Mappings, and Converter are now HIPAA eligible.

EDI Core, Mappings, and Converter are now HIPAA eligible. Developers can now use Stedi’s APIs to build business integrations and process transactions that contain Protected Health Information (PHI).

To start building HIPAA eligible systems using Stedi you will need to agree to a HIPAA Business Associate Addendum (BAA) with Stedi. To establish a BAA with Stedi, or if you have any other questions, please contact us. If you would like to learn more about HIPAA on Stedi, you can read our documentation

March 4, 2022

Mappings API is now multi-region

Since launch, Mappings served traffic from a single geographic region. Now, Mappings serves traffic from multiple regions. This will increase the reliability of the service in the case of a regional outage, and decrease latency for requests made geographically closer.

February 25, 2022

API for managing API keys is now generally avaialable

Requests to Stedi APIs are authenticated using a secret token called an API key. Each API key belongs to a single account and each account can have multiple API keys. API keys can be created inside of the Stedi UI by navigating to the API keys tab.

With the launch of the API for creating, listing, and deleting API keys, you can now manage this process programmatically. To learn more, you can read our documentation and API reference.

February 22, 2022

Prettier plugin for JSONata language

Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary.

Since developers use JSONata in the Mappings product, Stedi has contributed to Prettier by adding the prettier-plugin-jsonata, which uses the JSONata parser available as part of the jsonata package.

Here is what JSONata looks like in the Mappings transformation editor before formatting:

Prettier before

…and after formatting:

Prettier after

February 11, 2022

Converter is Generally Available

Converter is an API that allows developers to convert various formats like CSV and XML to JSON, providing a hassle-free way to manage these conversions. Converter has a transparent, pay-per-use pricing model with a generous free tier. There are no minimum fees, monthly commitments, or upfront costs to use this product.

In the example below, the Converter API uses the headers in the CSV as keys in the JSON. The result is a list with an object for each row, where the object has a field for each column. So, if you have a CSV like this…


…the resulting JSON will look like this:

   "output": [
           "type": "invoice",
           "invoiceNumber": "INV20023",
           "poNumber": 30278099,
           "amt": 100.5
           "type": "invoice",
           "invoiceNumber": "INV20024",
           "poNumber": 30288899,
           "amt": 50.99

If you’re ready to start building, check out the example TypeScript project in our public Starter-Kit repo or you can use our Postman collection to start hitting the API today.

February 10, 2022

Mappings: Increased maximum document size

To support developers working with larger JSON documents, we have increased the maximum mapped document size from 1 megabyte to 4 megabytes in order to accommodate a wider range of use cases. To learn more about Mappings limits, see our documentation here.

Mappings: $currentDateTime function

You can now use $currentDateTime function to generate current date and time in different formats and timezones. For example, if you want to generate a current date in an EDI format, you can achieve this by $currentDateTime($dateTime.EDIDate). If you need to have it generated for a different timezone, you can do so by specifying the 2nd argument like so: $currentDateTime($dateTime.EDIDate, "Europe/Berlin"). Read more

February 9, 2022

EDI Core APIs are now multi-region

Since launch, EDI Core served traffic from a single geographic region. Now, EDI Core serves traffic from multiple regions. This will increase the reliability of the service in the case of a regional outage, and decrease latency for requests made geographically closer.

Mappings: Lookup tables

You can now add one or more lookup tables to your mappings. Lookup tables are powerful for use cases where you have a field that contains a code and you wish to replace it with a related value. For example, if you have a source field with a country code (USA) and you want to replace it with the country name (United States), you can achieve this by building a countries lookup table:

Example of a countries lookup table

You can then use the lookup table in your mapping expression with the $lookupTable function:

Example usage of a countries lookup table

To learn more, see: Mappings documentation, Mappings API documentation.

February 7, 2022

EDI Core: Embed EDI payload into Launch snippets

Now, when you explore an EDI file in Inspector, the Launch modal will generate a code snippet using that EDI payload.

Launch payload

Mappings: Ability to explicitly omit fields from the mapping output

Mappings now supports omitting fields from the mapping output using the $omitField constant.

If a given expression evaluates the $omitField constant, the field the expression is defined for will be omitted in the output. The $omitField constant is compatible with all mapping types and all JSONata expressions.

To learn more, refer to the Mappings documentation here.

February 1, 2022

EDI Core: Launch modal with sample code snippets

We added a new Launch modal in Inspector with code snippets for making a HTTP request, cURL, Node.js + Axios, Python + Requests. Simply copy the code into a tool of your choice, insert your API key and a sample payload, and beging translating between EDI and JEDI programmatically.


January 31, 2022

EDI Inspector: inspect the ISA and GS elements, collapse segments in Rich view

You can now inspect individual elements in the ISA and GS segments.

To make working with large files easier, we have added the functionality to collapse segments in the Rich view. View example in Inspector


EDI Inspector: ability to download EDI file and improved data rendering

You can now save an EDI file from the Inspector editor.

We also improved data rendering format making the EDI file more human-readable:

  • Dates previously displayed as 20210901 now are shown as Sep 1, 2021.
  • Prior to the change, X12 elements that had a paired relational constraint were displayed as two separate entries. Example:
Communication Number Qualifier: Internet Email Address <> EA
Communication Number:

We now combine these into a single entry, with the qualifier as the label. You can click on either of these values to see the relevant reference information.

Internet Email Address <> EA :


EDI Reference: Human-readable conditions

The EDI Reference has been updated to display a human-readable interpretation of relation condition code (ex. P0304: If either PER-03 or PER-04 is present, then the other is required). Before the enhancement, only the relation condition code was provided, which was difficult to parse (ex. P0304). See example


January 20, 2022

Mappings: Launch modal with sample code snippets

When you create or import a mapping, you can now open a Launch modal with code snippets in cURL, Node.js + Axios, Python + Requests. Simply copy the code into a tool of your choice, insert your API key and a sample payload to try out the mapping.


EDI Core: format EDI files

You can now prettify unformatted EDI files in Inspector and through the /prettify endpoint.

Format EDI in Inspector

January 12, 2022

EDI Core: generate sample EDI files

You can now generate a sample EDI file from each and every transaction set on EDI Reference.

Example of the sample file generation

January 10, 2022

EDI Core: parse EDI files without envelopes

As a consumer of the /translate EDI core API, you now have the ability to parse EDI files that do NOT have envelopes. Before this enhancement, parsing a file without ISA/IEA GS/GE segments would result in a 422 response. Now, the EDI Core API will return a response based on the desired output parameters. The API response will identify the missing envelopes and elements for you.

View the response of the following payload in the inspector here:

REF*K6*A composable platform for building flexible EDI systems~
PO1**1*2P*0.0001*PE*GE*EDI Core~

EDI Core: parse segments not in spec

The /translate EDI core API has been updated to support the parsing of segments that are not part of a given X12 release. Before this update, such a segment would result in a 422 response. Now, the API will return a valid response that clearly identifies the segment in question.

View the response of the following payload in the inspector here

AUD*K6*<--AUD is NOT part of the 850 spec -->~
PO1**1*2P*0.0001*PE*GE*EDI Core~

January 7, 2022

EDI Core: remove empty segments

You are now able to specify the option to remove_empty_segments in the output_options of the EDI Core API.

 "output_options": {
    "generate_control_numbers": true,
    "remove_empty_segments": true

This feature can be helpful in cases when you're translating from JEDI to EDI and you wish to omit blank segments. Read more

Announcing 98% price decrease for Mapping requests

As of January 1, 2022, Mapping has a new pricing table, seen here. The decreased price of $0.001 per request for new and existing customers costs 98% less than the previous price of $0.05 (for volumes between 101-1,000,000 requests a month).

The price per request is tiered and the first 100 requests per month are free.

Request CountPrice
First 100Free
From 101 to 1,000,000$0.001
Above 1,000,000Contact us

January 6, 2022

JEDI 2.0 format is now available in production

Until now, the new JEDI 2.0 format was in "beta" as it stabilized. As of today, JEDI 2.0 is now ready for production use and comes with long-term support and commitment to no breaking changes.

You can read more about the JEDI@2.0 format here.

Below is an example of a JEDI 2.0 file.

  "interchanges": [
      "interchange_control_header_ISA": {
        "authorization_information_qualifier_01": "no_authorization_information_present_no_meaningful_information_in_i02_00",
        "authorization_information_02": "",
        "security_information_qualifier_03": "no_security_information_present_no_meaningful_information_in_i04_00",
        "security_information_04": "",
        "interchange_id_qualifier_05": "mutually_defined_ZZ",
        "interchange_sender_id_06": "",
        "interchange_id_qualifier_07": "mutually_defined_ZZ",
        "interchange_receiver_id_08": "",
        "interchange_date_09": "210902",
        "interchange_time_10": "1200",
        "repetition_separator_11": "/",
        "interchange_control_version_number_code_12": "00801",
        "interchange_control_number_13": "123456789",
        "acknowledgment_requested_code_14": "interchange_acknowledgment_requested_ta1_1",
        "interchange_usage_indicator_code_15": "test_data_T",
        "component_element_separator_16": ":"
      "groups": [
          "functional_group_header_GS": {
            "functional_identifier_code_01": "ocean_shipment_information_304_311_317_319_322_323_324_325_326_361_SO",
            "application_senders_code_02": "00",
            "application_receivers_code_03": "00",
            "date_04": "20210902",
            "time_05": "1200",
            "group_control_number_06": "987654321",
            "responsible_agency_code_07": "accredited_standards_committee_x12_X",
            "version_release_industry_identifier_code_08": "008010"
          "transaction_sets": [
              "heading": {
                "transaction_set_header_ST": {
                  "transaction_set_identifier_code_01": "326",
                  "transaction_set_control_number_02": "0000"
                "transaction_set_trailer_SE": {
                  "number_of_included_segments_01": "2",
                  "transaction_set_control_number_02": "0000"
              "type": "326"
          "functional_group_trailer_GE": {
            "number_of_transaction_sets_included_01": "1",
            "group_control_number_02": "987654321"
      "interchange_control_trailer_IEA": {
        "number_of_included_functional_groups_01": "1",
        "interchange_control_number_02": "123456789"
      "delimiters": {
        "element": "*",
        "segment": "~",
        "sub_element": ":",
        "repetition": "/"

January 5, 2022

Announcing 85% price decrease for EDI Core requests

As of January 1, 2022, EDI Core has a new pricing table. The decreased price of $0.0075 per request for new and existing customers costs 85% less than the previous price of $0.05 (for volumes between 101-1,000,000 request a month).

The price per request is tiered and the first 100 requests per month are free.

Request CountPrice
First 100Free
From 101 to 1,000,000$0.00750
Above 1,000,000Contact us

API bytes processed per request pricing

The price per KiB is a flat 0.00005 per KiB.

1 KiB$0.00005

January 5, 2022

Mappings: "duplicate mapping" functionality

You are now able to duplicate an existing Mapping by clicking the "Duplicate" icon next to each Mapping in the Mappings list page:

Example of the Duplicate Mapping functionality

January 1, 2022

EDI Core and EDI Reference now support X12 Version 3 releases, dating back to 1991

EDI Reference provides users with comprehensive EDI documentation and X12 table data. Until now, Stedi only had support for all X12 table data from Version 4-8 (1998-present). Now, users who are still on older formats can access table data from Version 3 (003010 - 003070) dating back to 1991.

EDI Core's translate API enables users to translate between X12 and JEDI (JSON EDI), with validation against the specified release. Now, users can validate their X12 files against Version 3 releases using EDI Core.


December 23, 2021

Mappings: example source/target files

You are now able to load a sample source/target JSON to quickly get started experimenting with Mappings. Until now, you had to provide your own JSON files to map.


December 14, 2021

Mappings: support for array-of-objects JSON documents

Mappings now supports using the JSON array-of-objects structure as both source and target documents when building a mapping.

JSON documents converted from tabular data formats, like CSV, XML, etc., do not have a top-level object by default. Until now, it was impossible to set the looping context correctly, without manually adding a top-level object.

With the expanded support of the JSON specification in Mappings, JSON array-of-objects structure can be used as the source and target documents, without the need for manual adjustments and additional transformations before and after the mapping request.

To learn more, refer to the JSONata array-of-objects cheatsheet here.

December 13, 2021

Optional envelope trailers

The following X12 EDI envelope trailers are now optional when converting JEDI 2.0 to EDI:


When these trailers are not included in the input JEDI, they are automatically generated based on the contents of the corresponding header and envelope. This simplifies the generation of EDI for users, as they can avoid potentially toilsome tasks such as counting the number of segments nested within a transaction set.


December 7, 2021

Date and time conversion functions for Mappings

Mappings now has a $convertDateTime function which makes date formatting and parsing easier (see examples below). On top of that, Mappings now also provides $dateTime const with common date formats. See the documentation here

 $convertDateTime("20140919", "yyyyMMdd",  "yyyy-MM-dd") → "2014-09-19"
 $convertDateTime("2021-01-02T12:00:00Z", $dateTime.RFC3339,  "yyyy-MM-dd") → "2021-01-02"
 $convertDateTime("2021-01-02T12:00:00+00:00", $dateTime.RFC3339,  "yyyy-MM-dd") → "2021-01-02"
 $convertDateTime("210102", $dateTime.EDIDate, $dateTime.RFC3339) → "2021-01-02T12:00:00Z"
 $convertDateTime("12:00 2nd January 2021", "hh:mm do MMMM yyyy",  "yyyy-MM-dd") → "2021-01-02"

December 6, 2021

EDI Core number conversions

Numbers stored in EDI may have adjustments applied to them based on how they're defined in a mapping guide. For instance, in an Invoice (810), you return the invoice's total not as 34.95, but as 3495. This field is noted as type "N2", meaning "this number has two decimal places."

With this change to JEDI@2.0-beta when using the EDI Core API, we handle the math for you - numbers provided with N types in the EDI will be converted to their real values in the JEDI document on the other end. Of course, if you translate JEDI to X12, we will handle this as well.

In the example below, we convert the 1450 in the SAC05 in the X12 on the left to 14.50 in the "amount_05" on the JEDI on the right.


December 3, 2021

Control numbers API for EDI Core

There is now an API to set the value of a control-number sequence for a specific sender+receiver pair. See the documentation in API Reference here.

The next generated control number will be the 1 + the value that you set. Control numbers roll back to 1 when reaching 1e9.

Inspector now supports JEDI 2.0 (Beta) and renders dates and times nicely

The Inspector now supports and displays JEDI@2.0-beta when viewing JSON.

We've also added custom renderers to nicely display dates and times, as well as numeric and decimal data types into the "rich view" of the Inspector.

EDI Core accepted codes list

There is a new output option to include_accepted_code_list for Jedi@1.0 and Jedi@2.0-beta. If enabled, a list of accepted_codes will be returned in the validation errors. This is disabled by default. This will help provide clearer error/validation messages. As an example of a validation error result:

    "code": "invalid_id",
    "message": "Invalid code value 'X' specified for element N1-01",
    "path": [
    "severity": "error",
    "accepted_codes": [

New homepage for EDI Reference

/edi has a brand new homepage. There you can search for any Element, Segment or Transaction Set and you can also see all the available X12 releases we have on the site.


November 30, 2021

Mappings: support for functions when setting Looping Context

In many mapping scenarios, a source document might contain one or more JSON arrays. In order to map an array like that to a different array on the target document, you need to specify a looping context (see Mapping Loops).

Previously, you could only loop over all items on the source array and map each item, but it was not possible to change the order of the array elements or exclude certain array items from the result.

Today, we are adding support for JSONata functions usage when setting a Looping Context. With the support from $filter, $sort, $reverse, and other functions you should be able to translate an array of any shape to the desired format.

For example, assuming that the orders below are coming in a random sorting order, you can adjust that order and sort the result by orderDate before mapping them to shipments:


November 25, 2021

Mappings: ability to restore unsaved changes

In addition to a friendly prompt to save your changes when leaving the Edit Mapping page, we've started to preserve unsaved changes in Local Storage inside the browser to further reduce the risk of losing any unfinished state of a mapping session.

Now, if you've spent a few hours building or editing a mapping, but you're not ready to submit the changes yet, you can leave the website and get an option to restore your in-progress state when you return to the same mapping.


It is important to note that only the last mapping session gets stored in Local Storage, so if you have multiple mappings to edit simultaneously, it is still advised to save your changes before closing the browser tab.

November 23, 2021

Stedi launches Mappings

Mappings is a powerful, highly-available service built to create, test and run mappings between various JSON documents – from simple value-to-value data mapping to highly complex data transformations.

For the last 50 years, businesses across all industries have been utilizing EDI to send and receive commercial transactions like purchase orders and invoices with their trading partners. Given the immense range of available standards, data formats, and API shapes, mappings between input and output files are necessary. However, existing mapping tools are lagging behind modern software tooling in terms of API-driven accessibility, scalability, high-availability, and user experience. A large portion of these systems live on-prem, and are only accessible via legacy interfaces and protocols – making it hard to integrate with today’s software solutions.

For example, let's say you have a document that looks like this

  "product": {
    "id": "QL-5490S",
    "price": "USD 500"

but you need it to look like this

  "product_number": "QL-5490S",
  "price": {
    "currency": "USD",
    "amount": 500

then Mappings can help you. Once you've created the proper mapping rules, Mappings can turn any document with the first structure into a document with the second structure. There are many situations where this is helpful, including:

  • You receive data from a trading partner, but it's not in the format that your own software system can handle.
  • You need to call an API and it expects data in a format that's different than what your own software system uses.
  • You want to map the data on a purchase order directly onto an invoice.

There are no minimums, monthly fees, or setup fees to use Mappings – customers only pay for the number of times their mapping is executed, starting at $0.05 per request. The first 100 requests per month are free.

To get started building Mappings, please visit

November 19, 2021

JEDI 2.0-beta

We released the second major revision of the JEDI format as a beta this week. This gives us some major readability gains over the original JEDI format, including:

  • We present the names of segments in addition to their IDs, so you have some context as to what each segment is representing
  • Similarly, we have added element descriptions along with their position in the segment
  • We also have updated how code values are provided/returned, with the codes being expanded to their representative text. We call out structural pieces of the document as well - loops are identified by the first segment of the loop (where jedi@1.0 sometimes had reference names that were just a numerical string), and each loop is designated with a _loop suffix.
  • We've added a couple of convenience attributes to the documents, so now you have an easier property on which to identify release and transaction set for a given document (at interchanges.*.release and interchanges.*.groups.*.transaction_set)
  • By default, we are trimming ISA header whitespace, but by supplying the clean_envelope_whitespace: false flag, this can be disabled. This differs from JEDi@1.0 which has this feature off by default. We're also still in beta, so we may make further tweaks and adjustments as time goes on, based on customer input and how people are using the documents. Please send us your feedback!

Compressed Response

Translating EDI to JEDI2.0 results in a much larger payload than the original request (and larger than the existing JEDI1.0 format). Now we compress all responses (larger than 5.5 kb) from the API. This compression is transparent to the customer as most http request clients and all browsers will decompress the response for them.

October 28, 2021

Sorted JSON

In order to make JEDI easier to read when it returns from our /translate endpoint, we have applied a custom sorting to the JSON renderer. JEDI will now order JEDI as the segments and elements are ordered in EDI. The order be will be preserved in node or browser applications. Other platforms may not keep the key ordering.

  "interchanges": [
      "ISA": {
        "01": "00",
        "02": "          "
      "groups": [
          "GS": {
            "01": "PO",
            "02": "SENDERGS",
            "08": "004010"
          "transaction_sets": [
              "heading": {
                "010_ST": {
                  "01": "850",
                  "02": "000000001"
                "020_BEG": {
                  "01": "00",
                  "02": "SA",
                  "03": "A99999-01",
                  "05": "19970214"
              "detail": {},
              "summary": {}
          "GE": {
            "01": "1",
            "02": "1"
      "IEA": {
        "01": "1",
        "02": "000000001"
      "delimiters": {
        "element": "*",
        "segment": "~",
        "sub_element": ">"

__version field in JEDI documents

To distinguish between versions of JEDI documents, we've added an attribute called __version to the response of /translate.

  "code": "valid",
  "output": {
    "__version": "jedi@1.0",
    "interchanges": {...},
    "meta": {...},

Trimmed ISA white space in JEDI documents

Added new output option to trim the ISA whitespace if enabled. Today, the ISA in JEDI format looks like

"ISA": {
  "01": "00",
  "02": "          ",
  "03": "00",
  "04": "          ",
  "05": "ZZ",
  "06": "TCWDEPOT       ",
  "07": "ZZ",
  "08": "FVLI0006       ",
  "09": "210202",
  "10": "0235",
  "11": "U",
  "12": "00200",
  "13": "005787399",
  "14": "0",
  "15": "P",
  "16": ":"

If clean_envelope_whitespace is set to true, it instead outputs as:

"ISA": {
  "01": "00",
  "02": "",
  "03": "00",
  "04": "",
  "05": "ZZ",
  "06": "TCWDEPOT",
  "07": "ZZ",
  "08": "FVLI0006",
  "09": "210202",
  "10": "0235",
  "11": "U",
  "12": "00200",
  "13": "005787399",
  "14": "0",
  "15": "P",
  "16": ":",

JSON EDI view in the Inspector

You can now toggle between "Rich view" and "JSON view" in the Inspector. The JSON view displays the EDI input in our custom JSON EDI (JEDI for short) format, along with the same annotations that were present in Terminal, for faster manual scanning of the file.


Support missing X12 003XXX versions

Support for 003040 and 003030 are now visible from our EDI Reference. More to come.

Faster EDI Inspector experience on the web

A missing header on responses from EDI Core meant that browsers would always need to issue two synchronous requests in order to translate and validate payloads in EDI Inspector. The addition of the missing headers speeds up the experience considerably, especially for users far away from Virginia, USA.

October 22, 2021

EDI Translate improvements in Terminal

To improve the legibility of JEDI v1 in Terminal, a description was added next to each segment and element.

Terminal JEDI Viewer

ISA segment padding

The ISA segment of an X12 EDI document has fixed width fields for each element so the length of the segment always turns out the exact same length. Previously, converting from JEDI to EDI required that ISA elements be of accurate length.

X12 3XXX releases

Support for 3050, 3060, and 3070 X12 releases has been added to EDI Reference and EDI Core's /translate endpoint.

April 25, 2022April 14th, 2022JSONata Playground: Experiment writing JSONata experessionsMarch 24, 2022March 10, 2022March 4, 2022February 25, 2022February 22, 2022February 11, 2022February 10, 2022February 9, 2022February 7, 2022February 1, 2022January 31, 2022January 20, 2022January 12, 2022January 10, 2022January 7, 2022January 6, 2022January 5, 2022January 5, 2022January 1, 2022December 23, 2021December 14, 2021December 13, 2021December 7, 2021December 6, 2021December 3, 2021November 30, 2021November 25, 2021November 23, 2021November 19, 2021October 28, 2021October 22, 2021