> This page is for API, version 2026-01-01 (Stable) (default).
> For other versions, use one of these documentation indexes:
> - 2026-01-01 (Stable) (default): https://developer.deel.com/api/stable/llms.txt
> - Beta: https://developer.deel.com/api/beta/llms.txt
> - Deprecated: https://developer.deel.com/api/deprecated/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.deel.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.deel.com/_mcp/server.

# Retrieve the Child Account onboarding intent type

GET https://api.letsdeel.com/rest/intent-types/child-account-onboarding

Returns the definition of the Child Account onboarding intent type. Use it before opening an intent to learn what the onboarding involves, which steps a person must complete by hand and which steps the partner can do through the API.

 **Token scopes**: `organizations:read`

 **Beta**: this version requires the `X-Beta: true` request header and its contract may change before it is promoted to stable. It is scheduled to become stable on 2027-02-16.

Reference: https://developer.deel.com/api/reference/endpoints/intents/retrieve-child-account-onboarding-intent-type-v-2026-11-16

## Authentication

- `Authorization` header (bearer token, required) — ## Authentication The Deel API uses bearer tokens to authenticate requests. All API calls must be made over HTTPS — calls over plain HTTP or without authentication will fail. ```curl curl -X GET 'https://api.letsdeel.com/rest/v2/contracts' \ -H 'Authorization: Bearer YOUR-TOKEN-HERE' ``` [Learn more about authentication](/api/authentication)
- `Authorization` header (bearer token, required) — Standard OAuth2 security scheme based on https://swagger.io/docs/specification/authentication/

## Servers

- `https://api.letsdeel.com/rest` (Production, default)
- `https://api-staging.letsdeel.com/rest` (Demo)

## Request

### Headers

- `X-Beta` (enum, required, default: true) — Opts in to the beta version of this endpoint. Must be `true`.
  - Allowed values: `true`

## Response

### 200

The intent type and its versions.

- `data` (IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaData, required) — The intent type and its versions.

## Errors

### 400 Bad Request Error

Operation failed.

- `errors` (list of IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 401 Unauthorized Error

Operation failed.

- `request` (ApiErrorRequest, optional)
- `errors` (list of ApiError, optional)

### 403 Forbidden Error

Operation failed.

- `request` (ApiErrorRequest, optional)
- `errors` (list of ApiError, optional)

### 404 Not Found Error

The type does not exist or is not open to your organization.

- `fix` (IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaFix, required) — How to fix the error.
- `code` (string, required) — Stable code of the error.
- `type` (string, required) — Class of the error.
- `message` (string, required) — What went wrong.

### 500 Internal Server Error

Operation failed.

- `errors` (list of IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

## Types

### IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaData

The intent type and its versions.

- `type` (string, required) — Name of the intent type.
- `title` (string, required) — Short name of the type for a person.
- `exposure` (enum, required) — Who can see the type. `PUBLIC` types are open to every partner with the feature enabled.
  - Allowed values: `PUBLIC`
- `versions` (list of IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaDataVersionsItems, required) — Every version of the type.
- `when_to_use` (string, required) — When to use this type.
- `latest_version` (string, required) — The newest version of the type.
- `when_not_to_use` (list of string, required) — Cases where another route is the right one.

### IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaErrorsItems

- `code` (string, optional) — Machine-readable error code
- `message` (string, optional) — Human-readable explanation of the error

### ApiErrorRequest

- `method` (string, optional) — The HTTP method of the failed request
- `url` (string, optional) — The relative URL of the failed request
- `status` (double, optional) — The status code of the response
- `api_req_id` (string, optional) — The request ID of the failed request
- `docs` (string, optional) — A link to the official documentation for the requested endpoint resource
- `source` (string, optional) — The source handler which produced the returned error
- `code` (double, optional) — The code of the source handler which produced the returned error

### ApiError

- `message` (string, optional) — A description of the returned error
- `path` (string, optional) — The JSON path where input validation failed

### IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaFix

How to fix the error.

- `hint` (string, required) — What to change.
- `action` (string, optional) — Key of the step to do next.
- `conflicting_intent` (string, optional) — Id of the open intent that blocks the call. Only on CONFLICTING_INTENT.

### IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaDataVersionsItems

- `open` (IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaDataVersionsItemsOpen, required) — The call that opens an intent of this type.
- `steps` (list of IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaDataVersionsItemsStepsItems, required) — The steps of an intent of this version, in order.
- `manual_steps` (list of string, required) — Keys of the steps that a person does outside the API. Empty when every step has an API path.
- `type_version` (string, required) — Version of the type, as a date.
- `statuses_used` (list of enum, required) — The statuses an intent of this version uses.
  - Allowed values: `CANCELED`, `REQUIRES_ACTION`, `SUCCEEDED`

### IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaDataVersionsItemsOpen

The call that opens an intent of this type.

- `path` (string, required) — Path that opens an intent of this type.
- `method` (enum, required) — HTTP method.
  - Allowed values: `POST`
- `body_schema` (map from string to any, required) — JSON Schema (draft 2020-12) of the request body of the open call.

### IntentTypesChildAccountOnboardingGetResponsesContentApplicationJsonSchemaDataVersionsItemsStepsItems

- `key` (string, required) — Key of the step. One key space for requirements and actions.
- `actor` (enum, required) — Who does the step.
  - Allowed values: `CLIENT`
- `group` (string, required) — Group of steps that share one mechanism.
- `owner` (string, required) — Team that owns the step.
- `title` (string, required) — Short name of the step for a person.
- `confirm` (enum, required, nullable) — Who must confirm the step. `HUMAN` means a person must do it. Null means no confirmation.
  - Allowed values: `HUMAN`
- `depends_on` (list of string, required) — Keys of the steps that must be done before this step is due.
- `body_schema` (map from string to any, required) — JSON Schema (draft 2020-12) of the request body of the action for this step.
- `next_action_type` (enum, required) — How the caller does the step. `REDIRECT` sends a person to a link. `CALL` is an API call.
  - Allowed values: `CALL`, `REDIRECT`

## Examples

**Response**

```json
{
  "data": {
    "type": "CHILD_ACCOUNT_ONBOARDING",
    "title": "Child Account onboarding",
    "exposure": "PUBLIC",
    "versions": [
      {
        "open": {
          "path": "/rest/intents/child-account-onboardings",
          "method": "POST",
          "body_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "data": {
                "additionalProperties": false,
                "properties": {
                  "organization_id": {
                    "description": "Id of the Child Account to onboard.",
                    "minLength": 1,
                    "type": "string"
                  },
                  "payment_method": {
                    "additionalProperties": false,
                    "properties": {
                      "rail": {
                        "enum": [
                          "US_ACH"
                        ],
                        "type": "string"
                      }
                    },
                    "required": [
                      "rail"
                    ],
                    "type": "object"
                  },
                  "signer": {
                    "additionalProperties": false,
                    "description": "The person who signs for the Child Account.",
                    "properties": {
                      "email": {
                        "format": "email",
                        "type": "string"
                      },
                      "name": {
                        "minLength": 1,
                        "type": "string"
                      }
                    },
                    "required": [
                      "name",
                      "email"
                    ],
                    "type": "object"
                  }
                },
                "required": [
                  "organization_id",
                  "signer",
                  "payment_method"
                ],
                "type": "object"
              }
            },
            "required": [
              "data"
            ],
            "type": "object"
          }
        },
        "steps": [
          {
            "key": "accept_terms",
            "actor": "CLIENT",
            "group": "signer_session",
            "owner": "White Label",
            "title": "Accept Deel's terms",
            "confirm": "HUMAN",
            "depends_on": [],
            "body_schema": {
              "$schema": "https://json-schema.org/draft/2020-12/schema",
              "additionalProperties": false,
              "type": "object"
            },
            "next_action_type": "REDIRECT"
          },
          {
            "key": "sign_poa",
            "actor": "CLIENT",
            "group": "signer_session",
            "owner": "White Label",
            "title": "Sign the power of attorney",
            "confirm": "HUMAN",
            "depends_on": [],
            "body_schema": {
              "$schema": "https://json-schema.org/draft/2020-12/schema",
              "additionalProperties": false,
              "type": "object"
            },
            "next_action_type": "REDIRECT"
          },
          {
            "key": "add_bank_account",
            "actor": "CLIENT",
            "group": "signer_session",
            "owner": "White Label, Accounting",
            "title": "Add the bank account",
            "confirm": "HUMAN",
            "depends_on": [],
            "body_schema": {
              "$schema": "https://json-schema.org/draft/2020-12/schema",
              "additionalProperties": false,
              "type": "object"
            },
            "next_action_type": "REDIRECT"
          },
          {
            "key": "authorize_ach_debit",
            "actor": "CLIENT",
            "group": "signer_session",
            "owner": "White Label",
            "title": "Authorize the ACH debit",
            "confirm": "HUMAN",
            "depends_on": [],
            "body_schema": {
              "$schema": "https://json-schema.org/draft/2020-12/schema",
              "additionalProperties": false,
              "type": "object"
            },
            "next_action_type": "REDIRECT"
          },
          {
            "key": "verify_bank_account",
            "actor": "CLIENT",
            "group": "verification",
            "owner": "ACH Payment API",
            "title": "Verify the bank account",
            "confirm": null,
            "depends_on": [
              "accept_terms",
              "sign_poa",
              "add_bank_account",
              "authorize_ach_debit"
            ],
            "body_schema": {
              "$schema": "https://json-schema.org/draft/2020-12/schema",
              "additionalProperties": false,
              "properties": {
                "data": {
                  "additionalProperties": false,
                  "properties": {
                    "amounts": {
                      "description": "The two deposit amounts the customer reads from the bank statement, in US dollars, for example 0.32.",
                      "items": {
                        "maximum": 0.99,
                        "minimum": 0.01,
                        "type": "number"
                      },
                      "maxItems": 2,
                      "minItems": 2,
                      "type": "array"
                    }
                  },
                  "required": [
                    "amounts"
                  ],
                  "type": "object"
                }
              },
              "required": [
                "data"
              ],
              "type": "object"
            },
            "next_action_type": "CALL"
          }
        ],
        "manual_steps": [],
        "type_version": "2026-11-18",
        "statuses_used": [
          "REQUIRES_ACTION",
          "SUCCEEDED",
          "CANCELED"
        ]
      }
    ],
    "when_to_use": "The end customer pays Deel directly, and Deel needs the consent and the payment method of the customer before it can bill the Child Account.",
    "latest_version": "2026-11-18",
    "when_not_to_use": [
      "The partner is liable for the bill.",
      "The bank account changes after the setup. Use the ACH Payment API."
    ]
  }
}
```

**SDK Code**

```python Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
import requests

url = "https://api.letsdeel.com/rest/intent-types/child-account-onboarding"

headers = {
    "X-Beta": "true",
    "Authorization": "Bearer <token>"
}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
const url = 'https://api.letsdeel.com/rest/intent-types/child-account-onboarding';
const options = {method: 'GET', headers: {'X-Beta': 'true', Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.letsdeel.com/rest/intent-types/child-account-onboarding"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-Beta", "true")
	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
require 'uri'
require 'net/http'

url = URI("https://api.letsdeel.com/rest/intent-types/child-account-onboarding")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-Beta"] = 'true'
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.letsdeel.com/rest/intent-types/child-account-onboarding")
  .header("X-Beta", "true")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.letsdeel.com/rest/intent-types/child-account-onboarding', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'X-Beta' => 'true',
  ],
]);

echo $response->getBody();
```

```csharp Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/intent-types/child-account-onboarding");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Beta", "true");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Intents_retrieveChildAccountOnboardingIntentType-v2026-11-16_example
import Foundation

let headers = [
  "X-Beta": "true",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/intent-types/child-account-onboarding")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```