REST Call From JSON

REST Call from JSON Payload — End-to-End Skill

Use this skill to generate the full stack of Mendix integration artifacts from a JSON payload: JSON Structure → Non-persistent entities → Import Mapping → microflow.

Two approaches: This skill uses the inline REST CALL approach (good for one-off calls and quick prototyping). For structured APIs with reusable operations, use the REST Client approach instead — see rest-client for create consumed rest service + send rest request

• optional transform with JSLT data transformers.

Overview — Four Steps

1. CREATE JSON STRUCTURE — store the raw payload and derive the element tree
2. CREATE ENTITY (non-persistent) — one per JSON object type, with attributes per JSON field
3. CREATE IMPORT MAPPING — link JSON structure elements to entities and attributes
4. CREATE MICROFLOW — inline REST CALL that invokes the import mapping (or use REST Client + SEND REST REQUEST)

Step 1 — JSON Structure

mdl 1;
create json structure Module.JSON_MyStructure
  sample '{"key": "value", "count": 1}';

• The executor formats the snippet (pretty-print) then refreshes (derives element tree) automatically.
• The snippet must be valid JSON; use single quotes around it in MDL.
• Escape single quotes inside the snippet by doubling them: ''.
• The derived element tree must stay consistent with the snippet — the executor sorts JSON object keys alphabetically to match json.MarshalIndent output.

Verify after creation:

describe json structure Module.JSON_MyStructure;
-- Should show: element tree under "-- Element tree:" comment

Step 2 — Non-Persistent Entities

Derive one entity per JSON object type. Name them after what they represent (not after JSON keys).

mdl 1;
create non-persistent entity Module.MyRootObject (
  stringField   : string,
  intField      : integer,
  decimalField  : decimal,
  boolField     : boolean default false
);

create non-persistent entity Module.MyNestedObject (
  name : string,
  code : string
);

create association Module.MyRootObject_MyNestedObject
  from Module.MyRootObject
  to Module.MyNestedObject;

Rules:

• All string fields: bare string (no length — unlimited)
• All number fields: integer, decimal, or long — remove defaults for optional fields
• Boolean fields require default true|false
• non-persistent — these entities are not stored in the database. The keyword is hyphenated and goes before entity: create non-persistent entity Mod.X (...). NON_PERSISTENT, and a (NON_PERSISTENT) inside the body, are both parse errors
• One association per parent→child relationship; name it Parent_Child

Step 3 — Import Mapping

Full reference: See json-structures-and-mappings for complete import/export mapping syntax, domain model patterns, and common mistakes.

mdl 1;
create import mapping Module.IMM_MyMapping
  with json structure Module.JSON_MyStructure
{
  create Module.MyRootObject {
    stringField = stringField,
    intField    = intField,
    create Module.MyRootObject_MyNestedObject/Module.MyNestedObject = nestedKey {
      name = name,
      code = code
    }
  }
};

Syntax rules:

• Root object: create Module.Entity { ... } — always starts with handling keyword
• Value mappings: attributename = jsonFieldName — entity attribute on the left, JSON field on the right
• Nested objects: create association/entity = jsonKey { ... } — association path + JSON key
• Object handling: create (default), find (requires KEY), find or create
• KEY marker: attr = jsonField key — marks the attribute as a matching key
• Value transforms: attr = Module.Microflow(jsonField) — call a microflow to transform the value

Verify after creation — check Schema elements are ticked in Studio Pro:

• Open the import mapping in Studio Pro
• All JSON structure elements should appear ticked in the Schema elements panel
• If not ticked: JsonPath mismatch between import mapping and JSON structure elements

Step 4 — REST CALL Microflow

Place the microflow in the [pages]/Operations/ folder or Private/ depending on whether it is public.

create microflow Module.GET_MyData ()
begin
  @position(-5, 200)
  declare $baseUrl string = 'https://api.example.com';
  @position(185, 200)
  declare $endpoint string = $baseUrl + '/path';
  @position(375, 200)
  $Result = call rest service get '{1}' with ({1} = $endpoint) (
    Headers: ('Accept': 'application/json'),
    Timeout: 300,
  ) returns mapping Module.IMM_MyMapping as Module.MyRootObject on error rollback;
  @position(565, 200)
  log info node 'Integration' 'Retrieved result' with ();
end;
/

Key points:

• @position annotations control the canvas layout — StartEvent is auto-placed 150px to the left of the first annotated activity
• The output variable name is automatically derived from the entity name in as Module.MyEntity — do NOT hardcode it on the left side; the executor overrides it
• Single vs list result is automatically detected: if the JSON structure's root element is an Object, the variable type is ObjectType (single); if Array, ListType (list)
• on error rollback — standard error handling for integration calls

For list responses (JSON root is an array):

  $Results = call rest service get '{1}' with ({1} = $endpoint) (
    Headers: ('Accept': 'application/json'),
    Timeout: 300,
  ) returns mapping Module.IMM_MyMapping as Module.MyItem on error rollback;
  @position(565, 200)
  $count = count $MyItem;

Step 5 — Import/Export Mapping in Microflows (Optional)

Instead of using returns mapping on a REST CALL, you can use standalone import/export mapping actions. This is useful when you already have a JSON string and want to map it to entities, or when you want to serialize entities back to JSON.

Import from mapping

Applies an import mapping to a string variable (JSON content) to produce entity objects:

-- With assignment (non-persistent entities, need the result in the flow)
$PetResponse = import from mapping Module.IMM_Pet($JsonContent);

-- Without assignment (persistent entities, just stores to DB)
import from mapping Module.IMM_Pet($JsonContent);

Export to mapping

Applies an export mapping to an entity object to produce a JSON string:

$JsonOutput = export to mapping Module.EMM_Pet($PetResponse);

Complete import → process → export microflow

mdl 1;
create microflow Module.ProcessPetData ()
begin
  declare $ResponseContent string = $latestHttpResponse/content;
  $PetResponse = import from mapping Module.IMM_Pet($ResponseContent);
  -- Process the imported data...
  $JsonOutput = export to mapping Module.EMM_Pet($PetResponse);
  log info node 'Integration' 'Exported: ' + $JsonOutput;
end;