Skip to main content
Parse commands enable you to extract and parse data from various formats including JSON, HTML, XML, and other structured data formats. These commands are essential for transforming raw data into usable structured formats.

Overview

Parse commands provide functionality for:
  • Extracting data using JSONPath queries
  • Parsing JSON structures
  • Transforming data formats
  • Extracting specific fields from complex data structures
  • Mapping data between different structures

Available Commands

Json Path

Extract data using JSONPath expressions (ID 1002)

String Manipulation

Perform string operations on specific fields in a collection of objects (ID 1003)

Filter

Selectively include or exclude objects from a collection based on field values (ID 1004)

Key Mapping

Map existing object keys to new keys (ID 1005)

Recursive JSON With Parent

Extract deeply nested child elements while preserving their parent-child hierarchy (ID 1006)

JSON Parse

Parse a JSON string in data into a structured object (ID 1007)

Sleep

Introduce a delay or pause in the execution of commands (ID 1008)

Regex

Apply regex operations on strings or arrays within a data source (ID 1009)

Distinct

Remove duplicate values from a collection based on a specified key (ID 1010)

Extract Keys

Extract the keys of objects from an array of child objects (ID 1011)

Key Mapping With JSONPath

Extract specific values using JSONPath queries and map them to new keys (ID 1012)

Insert To Children

Map specific parent attributes to child objects using JSONPath queries (ID 1013)

Array Join

Join values from an array using a specified delimiter (ID 1014)

String Split

Split a string field in child objects using a provided delimiter (ID 1015)

Object Mapper

Map and transform data structures (ID 1016)

Transform By JDM

Transform data into a new object using JDM mapping rules (ID 1017)

Insert To Children By Query

Insert a field into child objects using a JSONPath query (ID 1018)

XML Parse

Parse an XML string into a structured JSON object (ID 1019)

Zen Parse Expression

Evaluate Zen expressions or unary conditions against input data (ID 1020)

Insert To Children By Query List

Insert multiple fields into child objects using a list of query and field name pairs (ID 1021)

JSONata

Evaluate JSONata expressions against input data (ID 1022)

Decode

Decode base64+LZ4 or base64+gzip payloads into JSON (ID 1023)

HTML Parse

Parse HTML strings into a JSON DOM tree (command ID 1024)

Common Use Cases

  • API Response Parsing: Extract specific fields from API responses
  • Data Transformation: Transform data structures for downstream processing
  • Field Extraction: Extract specific values from nested JSON structures
  • Data Mapping: Map data between different formats
  • Response Processing: Process and structure HTTP response data

JSONPath Syntax

JSONPath commands use JSONPath expressions to query JSON data. Common patterns include:

Common JSONPath Patterns

Extract all IDs:
Get first item:
Nested access:
Recursive search:

Command Parameters

Each Parse command has its own parameters; see its page. Every command in a Blueprint is an object with id, type ("PARSE") and params, and works on the previous command’s result, usually its data field. Parameters accept ${name} placeholders.

Best Practices

  • Test JSONPath Queries: Use the Test panel to validate JSONPath syntax
  • Verify Source Data Structure: Check actual data structure before writing queries
  • Use Descriptive Keys: Use clear, descriptive key names for extracted data
  • Handle Missing Data: Account for missing fields or null values
  • Start Simple: Begin with simple queries and build complexity gradually

Troubleshooting

JSONPath Queries Not Working

If JSONPath queries return no results:
  1. Verify Source Data: Check the actual structure of source data using the Test panel
  2. Test Syntax: Validate JSONPath syntax matches the data structure
  3. Check Source Selection: Ensure the correct source is selected
  4. Review Query Examples: Start with simpler queries and build complexity

Common Issues

  • Incorrect JSONPath Syntax: Verify syntax matches JSONPath specification
  • Data Structure Mismatch: Ensure query matches actual data structure
  • Missing Fields: Handle cases where expected fields may not exist
  • Null Values: Account for null or undefined values in data