> ## Documentation Index
> Fetch the complete documentation index at: https://80x.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Parse JSON

> The Parse JSON block converts a JSON string into typed variables that later workflow blocks can read.

The **Parse JSON** block (Utilities) converts a JSON string into typed variables that later workflow blocks can read. JSON is the plain-text format that webhooks and HTTP responses use to send data. This block turns that raw text into named fields you can map into records, conditions, and messages. You define a schema, which is the shape of the data you expect. A field whose type does not match the schema fails the block.

| | |
| - | - |
| **Category** | Utilities |
| **Credit cost** | Free. Logic blocks consume no credits. |
| **Engine** | New Workflows engine (June 2026+) |
| **Plan availability** | All plans |
| **Limits** | None documented. |

## Inputs

| Input | Type | Required | Default | Notes |
| - | - | - | - | - |
| Input | String | Yes | None | The JSON string to parse, usually `{{ steps.webhook_received.body }}` from [Webhook received](/reference/triggers/webhook-received) or the response body from [Send HTTP request](/reference/utilities/send-http-request). |
| Schema | Schema | Yes | None | The shape of the expected payload. Generate it from a sample JSON string or build it by hand. |
| Root type | Selection | Yes | None | The top-level JSON structure, such as an object or an array. |
| Properties | Field list | Yes | None | The fields to extract and the type of each one. Parse only the fields the workflow actually uses. |

## Outputs

| Output | Type | Example | Notes |
| - | - | - | - |
| Parsed values | Typed (per schema) | `jane@acme.com` | One output per property in the schema, each carrying the type you declared. |

Each property becomes its own variable. Reference a parsed `email` field downstream as `{{ steps.parse_json.email }}`. Reference a nested or array field by the path you defined in the schema.

## Behavior

Parse JSON reads the **Input** string, checks it against the **Schema**, and exposes one typed variable per property.

Mark a property as optional if it might be missing from the payload. When an optional property is absent, it returns empty instead of failing the run. Downstream blocks then have to handle that empty case.

A property whose value does not match its declared type fails the block and stops the run on that path. The parser does not silently convert one type into another. It will not turn a string into a number, or a number into a boolean.

Only the properties you declare in the schema become outputs. Adding a field to the source payload has no effect on its own. You also have to add that field to the schema.

## Gotchas

* **Type mismatch fails the block.** A field can arrive as a different type than the schema declares. For example, a number where you expect a string, or a string where you expect a boolean. When that happens, the block fails and the run stops on that path. Treat external payloads as untrusted. Declare the type the source actually sends. When a provider is inconsistent, widen that field to a string.
* **Missing optional values return empty, not an error.** An optional property that is absent from the payload resolves to empty instead of failing. A downstream [Create or update record](/reference/records/create-or-update-record) block can then write an empty value over good data. Guard it with a [Filter](/reference/conditions/filter) or an [If](/reference/conditions/if) check before the write.
* **Unparsed fields are invisible downstream.** Only properties in the schema appear as variables. If a field you need is missing from the variable picker, add it to the schema. Do not assume the block dropped it.

## Examples

### Parsing a webhook lead payload

A form provider posts a lead to your webhook URL. Parse JSON extracts the three fields the intake workflow needs.

```json theme={null}
{
  "email": "jane@acme.com",
  "company_domain": "acme.com",
  "source": "pricing-page"
}
```

| Field | Value |
| - | - |
| Input | `{{ steps.webhook_received.body }}` |
| Root type | Object |
| `email` | String |
| `company_domain` | String |
| `source` | String |

The block exposes `{{ steps.parse_json.email }}`, `{{ steps.parse_json.company_domain }}`, and `{{ steps.parse_json.source }}`. The next [Create or update record](/reference/records/create-or-update-record) block maps these onto a person.

### Parsing an enrichment API response

A [Send HTTP request](/reference/utilities/send-http-request) block calls an enrichment API. Parse JSON reads the typed fields out of the response body.

```json theme={null}
{
  "headcount": 240,
  "in_business": true,
  "industry": "SaaS"
}
```

| Field | Value |
| - | - |
| Input | `{{ steps.send_http_request.body }}` |
| Root type | Object |
| `headcount` | Number |
| `in_business` | Boolean |
| `industry` | String |

The block exposes `{{ steps.parse_json.headcount }}` as a number. A downstream [Filter](/reference/conditions/filter) can then compare it numerically before the workflow writes the company record.

## Source

[Attio Workflows block library](https://attio.com/help/reference/automations/workflows/workflows-block-library).

Last reviewed against the Attio Help Center, June 2026.

## See also

* [Send HTTP request](/reference/utilities/send-http-request)
* [Webhook received](/reference/triggers/webhook-received)
* [Variables & data passing](/explanation/variables)
* [HTTP and JSON patterns](/guides/platform-patterns/http-json-patterns)
* [Webhook lead intake with safe upsert](/guides/capture-and-qualify/webhook-lead-intake)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.