JSONPath Features

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 [*].

Array Wildcard
Object Wildcard
Nested Wildcard

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"]
}

Data

{
  "api_response": {
    "users": {
      "user1": {"name": "Alice", "age": 30},
      "user2": {"name": "Bob", "age": 25},
      "user3": {"name": "Charlie", "age": 35}
    }
  }
}

Mapping

{
  "allUsers": "$.api_response.users.*",
  "allNames": "$.api_response.users.*.name",
  "allAges": "$.api_response.users.*.age"
}

Result

{
  "allUsers": [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35}
  ],
  "allNames": ["Alice", "Bob", "Charlie"],
  "allAges": [30, 25, 35]
}

Data

{
  "departments": [
    {
      "name": "Sales",
      "employees": [
        {"name": "Alice", "role": "Manager"},
        {"name": "Bob", "role": "Rep"}
      ]
    },
    {
      "name": "Engineering",
      "employees": [
        {"name": "Charlie", "role": "Developer"},
        {"name": "Diana", "role": "Designer"}
      ]
    }
  ]
}

Mapping

{
  "allEmployeeNames": "$.node.departments[*].employees[*].name"
}

Result

{
  "allEmployeeNames": ["Alice", "Bob", "Charlie", "Diana"]
}

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).

Find All Occurrences
Deep Search

Data

{
  "fetch_data": {
    "user": {
      "contact": {
        "email": "user@example.com"
      }
    },
    "admin": {
      "contact": {
        "email": "admin@example.com"
      }
    },
    "support": {
      "email": "support@example.com"
    }
  }
}

Mapping

{
  "allEmails": "$.fetch_data..email"
}

Result

{
  "allEmails": [
    "user@example.com",
    "admin@example.com",
    "support@example.com"
  ]
}

Finds all email properties regardless of nesting level.

Data

{
  "company": {
    "departments": [
      {
        "name": "Sales",
        "manager": {"name": "Alice"},
        "teams": [
          {
            "name": "Team A",
            "lead": {"name": "Bob"}
          }
        ]
      },
      {
        "name": "Engineering",
        "manager": {"name": "Charlie"}
      }
    ]
  }
}

Mapping

{
  "allPersonNames": "$.node..name"
}

Result

{
  "allPersonNames": ["Sales", "Alice", "Team A", "Bob", "Engineering", "Charlie"]
}

Note: Returns ALL properties named “name”, including department and team names.

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].

Basic Slicing
Negative Indexes
Step Values

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]
}

Data

{
  "items": ["A", "B", "C", "D", "E", "F"]
}

Examples

{
  "lastThree": "$.node.items[-3:]",
  "allButLast": "$.node.items[:-1]",
  "secondToLast": "$.node.items[-2:-1]",
  "lastItem": "$.node.items[-1]"
}

Results

{
  "lastThree": ["D", "E", "F"],
  "allButLast": ["A", "B", "C", "D", "E"],
  "secondToLast": ["E"],
  "lastItem": "F"
}

Data

{
  "numbers": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}

Examples

{
  "everyOther": "$.node.numbers[::2]",
  "everyThird": "$.node.numbers[::3]",
  "evenIndexes": "$.node.numbers[0::2]",
  "oddIndexes": "$.node.numbers[1::2]"
}

Results

{
  "everyOther": [1, 3, 5, 7, 9],
  "everyThird": [1, 4, 7, 10],
  "evenIndexes": [1, 3, 5, 7, 9],
  "oddIndexes": [2, 4, 6, 8, 10]
}

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]

[0:3]    // First 3 items (index 0, 1, 2)
[2:]     // From index 2 to end
[:5]     // First 5 items
[-3:]    // Last 3 items
[::2]    // Every other item
[1::2]   // Every other item, starting at index 1

Parent Selector

Get the parent object of a matched item using the ^ operator.

Basic Parent Access
Filter Then Get Parent

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.

Data

{
  "store": {
    "inventory": [
      {"item": "Widget", "stock": 50},
      {"item": "Gadget", "stock": 5},
      {"item": "Doohickey", "stock": 100}
    ]
  }
}

Mapping

{
  "lowStockParent": "$.node.store.inventory[?(@.stock<10)]^"
}

First filters items with low stock, then ^ returns the parent inventory array.

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.

Object Property Names
Array Index Names
Nested Property Names

Data

{
  "api_response": {
    "user": {"name": "Alice"},
    "account": {"balance": 1000},
    "settings": {"theme": "dark"}
  }
}

Mapping

{
  "propertyNames": "$.node.api_response.*~"
}

Result

{
  "propertyNames": ["user", "account", "settings"]
}

Data

{
  "items": ["Apple", "Banana", "Cherry"]
}

Mapping

{
  "indexNames": "$.node.items[*]~"
}

Result

{
  "indexNames": ["0", "1", "2"]
}

For arrays, ~ returns string representations of indexes.

Data

{
  "config": {
    "database": {"host": "localhost"},
    "cache": {"ttl": 3600},
    "api": {"timeout": 30}
  }
}

Mapping

{
  "configSections": "$.node.config.*~",
  "databaseSettings": "$.node.config.database.*~"
}

Result

{
  "configSections": ["database", "cache", "api"],
  "databaseSettings": ["host"]
}

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.

Spaces in Names
Special Characters
Numeric String Keys

Data

{
  "api response": {
    "user data": {
      "first name": "Alice"
    }
  }
}

Mapping

{
  "userName": "$['api response']['user data']['first name']"
}

Result

{
  "userName": "Alice"
}

Data

{
  "response": {
    "property-with-dashes": "value1",
    "property.with.dots": "value2",
    "property@special": "value3"
  }
}

Mapping

{
  "value1": "$.node.response['property-with-dashes']",
  "value2": "$.node.response['property.with.dots']",
  "value3": "$.node.response['property@special']"
}

Data

{
  "data": {
    "123": "numeric string key",
    "456": "another numeric key"
  }
}

Mapping

{
  "first": "$.node.data['123']",
  "second": "$.node.data['456']"
}

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.

Dollar Sign Property
At Sign Property
Literal Backtick

Data

{
  "$price": 100,
  "$total": 500
}

Mapping

{
  "price": "$.node.`$price`",
  "total": "$.node.`$total`"
}

Without backticks, $ would be interpreted as the root operator.

Data

{
  "@timestamp": "2025-01-15T10:30:00Z",
  "@version": "2.0"
}

Mapping

{
  "timestamp": "$.node.`@timestamp`",
  "version": "$.node.`@version`"
}

Without backticks, @ would be interpreted as a filter variable.

Data

{
  "code": "`example`"
}

Mapping

{
  "value": "$.node.``code``"
}

Use double backticks to escape a literal backtick character.

Important Notes

Array Indexing

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]

Case Sensitivity

All JSONPath expressions are case-sensitive:

$.user.Name ≠ $.user.name
$.NODE_ID ≠ $.node_id
Property names must match exactly

Return Values

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

Performance

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

Get All Values
Slice Arrays
Get Structure

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

{
  "topThree": "$.leaderboard[0:3]",
  "recentFive": "$.logs[-5:]",
  "everyOther": "$.items[::2]"
}

{
  "sections": "$.config.*~",
  "firstLevelKeys": "$.*~",
  "arrayIndexes": "$.items[*]~"
}

Try It Yourself

Create Sample Data

Add a node that returns complex nested JSON data

Use Wildcards

Try [*] to select all items in an array

Try Recursive Search

Use ..propertyName to find all occurrences

Experiment with Slicing

Practice array slicing with different start:end:step combinations

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.

Get Started

Assistants

Flows

Account Management

Advanced

Wildcard Selection

Recursive Descent

Array Slicing

Slice Syntax

Parent Selector

Property Name Selector

Bracket Notation

Escaping Special Characters

Important Notes

Common Patterns

Try It Yourself

What’s Next?

Pipe Operator

Filters & Expressions

Examples

Reference

​Wildcard Selection

​Recursive Descent

​Array Slicing

​Slice Syntax

​Parent Selector

​Property Name Selector

​Bracket Notation

​Escaping Special Characters

​Important Notes

​Common Patterns

​Try It Yourself

​What’s Next?

Pipe Operator

Filters & Expressions

Examples

Reference

Wildcard Selection

Recursive Descent

Array Slicing

Slice Syntax

Parent Selector

Property Name Selector

Bracket Notation

Escaping Special Characters

Important Notes

Common Patterns

Try It Yourself

What’s Next?