Skip to main content
QuivaWorks uses JSONPath Plus v1.1.0 which provides powerful operators for querying and selecting data from complex structures.
These are standard JSONPath features that work across all JSONPath implementations. The next sections cover QuivaWorks-specific extensions.

​
Wildcard Selection

Select all elements at a specific level using the wildcard operator [*].
Data
{
  "fetch_orders": {
    "orders": [
      {"id": "ORD-001", "total": 99.99, "status": "shipped"},
      {"id": "ORD-002", "total": 149.99, "status": "pending"},
      {"id": "ORD-003", "total": 79.99, "status": "delivered"}
    ]
  }
}
Mapping
{
  "allOrderIds": "$.fetch_orders.orders[*].id",
  "allTotals": "$.fetch_orders.orders[*].total",
  "allStatuses": "$.fetch_orders.orders[*].status"
}
Result
{
  "allOrderIds": ["ORD-001", "ORD-002", "ORD-003"],
  "allTotals": [99.99, 149.99, 79.99],
  "allStatuses": ["shipped", "pending", "delivered"]
}
Wildcard [*] always returns an array, even if there’s only one item. If you need a single value, use an index like [0] instead.

​
Recursive Descent

Search for properties at any depth in the structure using .. (double dot).
Data
{
  "fetch_data": {
    "user": {
      "contact": {
        "email": "[email protected]"
      }
    },
    "admin": {
      "contact": {
        "email": "[email protected]"
      }
    },
    "support": {
      "email": "[email protected]"
    }
  }
}
Mapping
{
  "allEmails": "$.fetch_data..email"
}
Result
{
  "allEmails": [
    "[email protected]",
    "[email protected]",
    "[email protected]"
  ]
}
Finds all email properties regardless of nesting level.
When to use recursive descent:
  • Structure varies and you need to find all occurrences
  • You don’t know the exact depth of the property
  • You’re searching across multiple nested levels
When NOT to use:
  • You know the exact path (use direct path for better performance)
  • You only want a specific occurrence (use explicit path)

​
Array Slicing

Extract portions of arrays using slice notation [start:end:step].
Data
{
  "items": [
    {"id": 1, "name": "Item 1"},
    {"id": 2, "name": "Item 2"},
    {"id": 3, "name": "Item 3"},
    {"id": 4, "name": "Item 4"},
    {"id": 5, "name": "Item 5"}
  ]
}
Examples
{
  "firstThree": "$.node.items[0:3]",
  "middleTwo": "$.node.items[1:3]",
  "lastTwo": "$.node.items[3:5]",
  "fromThirdOnward": "$.node.items[2:]",
  "upToThird": "$.node.items[:3]"
}
Results
{
  "firstThree": [Item 1, Item 2, Item 3],
  "middleTwo": [Item 2, Item 3],
  "lastTwo": [Item 4, Item 5],
  "fromThirdOnward": [Item 3, Item 4, Item 5],
  "upToThird": [Item 1, Item 2, Item 3]
}

​
Slice Syntax

​
[start:end:step]
array slice
  • start - Index to begin at (inclusive, default: 0)
  • end - Index to stop at (exclusive, default: array length)
  • step - Increment between items (default: 1)
[start:end:step]

​
Parent Selector

Get the parent object of a matched item using the ^ operator.
Data
{
  "products": [
    {
      "name": "Laptop",
      "price": 999,
      "specs": {"cpu": "i7", "ram": 16}
    },
    {
      "name": "Mouse",
      "price": 25,
      "specs": {"wireless": true}
    }
  ]
}
Mapping
{
  "expensiveProduct": "$.node.products[?(@.price>100)]^"
}
The ^ returns the parent array containing the expensive items.
The parent selector is useful when you need to reference the container of filtered items, not just the items themselves.

​
Property Name Selector

Get property names instead of values using the ~ operator.
Data
{
  "api_response": {
    "user": {"name": "Alice"},
    "account": {"balance": 1000},
    "settings": {"theme": "dark"}
  }
}
Mapping
{
  "propertyNames": "$.node.api_response.*~"
}
Result
{
  "propertyNames": ["user", "account", "settings"]
}

​
Bracket Notation

With JSON path, you can access properties with special characters using bracket notation ['property']. QuivaWorks allows you to access properties with special characters without using this notation, however if you are experiencing unexpected results you can still use this notation.
Data
{
  "api response": {
    "user data": {
      "first name": "Alice"
    }
  }
}
Mapping
{
  "userName": "$['api response']['user data']['first name']"
}
Result
{
  "userName": "Alice"
}
When to use bracket notation:
  • Property names contain spaces
  • Property names contain special characters (. - @ # $ etc.)
  • Property names are numeric strings
  • Property names could be confused with JSONPath operators

​
Escaping Special Characters

Use backticks to escape property names that might conflict with JSONPath operators.
Data
{
  "$price": 100,
  "$total": 500
}
Mapping
{
  "price": "$.node.`$price`",
  "total": "$.node.`$total`"
}
Without backticks, $ would be interpreted as the root operator.

​
Important Notes

JSONPath uses 0-based indexing like JavaScript (not 1-based like XPath):
  • First element: [0]
  • Second element: [1]
  • Last element: [-1]
  • Second to last: [-2]
All JSONPath expressions are case-sensitive:
  • $.user.Name ≠ $.user.name
  • $.NODE_ID ≠ $.node_id
  • Property names must match exactly
Understanding what JSONPath returns:
  • Single property: Returns the value directly
  • Wildcard [*]: Always returns an array
  • Filter [?()]: Always returns an array
  • Recursive ..: Always returns an array
  • Slice [:]: Always returns an array
  • Non-existent path: Property is removed from output entirely
Fast operations:
  • Direct property access: $.node.property
  • Array index: $.node.items[0]
  • Specific paths: $.node.nested.property
Slower operations:
  • Recursive descent: $..property
  • Complex filters: $.items[?(@.x>5 && @.y<10)]
  • Multiple wildcards: $..*.*[*]
Use specific paths when possible for better performance.

​
Common Patterns

{
  "allEmails": "$.users[*].email",
  "allPrices": "$.products[*].price",
  "allIds": "$..id"
}

​
Try It Yourself

1

Create Sample Data

Add a node that returns complex nested JSON data
2

Use Wildcards

Try [*] to select all items in an array
3

Try Recursive Search

Use ..propertyName to find all occurrences
4

Experiment with Slicing

Practice array slicing with different start:end:step combinations
5

Test in Debugger

Verify results in the Flow Debugger

​
What’s Next?

Pipe Operator

Learn QuivaWorks’ string concatenation operator

Filters & Expressions

Filter and query data with conditional expressions

Examples

See real-world usage patterns

Reference

Complete syntax reference
Questions? Check the Reference or visit our Help Center.