> 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

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

# Add admins to child organizations

POST https://api.letsdeel.com/rest/organizations/children/admins
Content-Type: application/json

Add multiple admins to child organizations in one call (e.g., when a new team member joins). Provide the admins and target child organizations: people who are not members yet are invited by email, and existing members are made admins. People who are already admins are left unchanged and get no new invitation. The response shows results for each admin-organization pair.

 **Token scopes**: `organizations:write`

 **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-01-12.

Reference: https://developer.deel.com/api/reference/endpoints/organizations/add-child-organization-admins-v-2026-10-12

## 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`

### Body (application/json)

This endpoint expects an object.

- `data` (OrganizationsChildrenAdminsPostRequestBodyContentApplicationJsonSchemaData, required) — The request payload.

## Response

### 200

The outcome for every admin and child organization pair.

- `data` (OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaData, required) — The outcome of the request.

## Errors

### 400 Bad Request Error

Bad request. Nothing is written. Codes: VALIDATION_ERROR (the request body failed validation, for example a malformed email, an email or child organization id listed twice, or an empty list; the error item also carries a details object naming the offending key), GENERIC_ERROR (the number of admins multiplied by the number of child organizations is above 100). The API gateway rejects a schema-invalid request body before it reaches Deel; each error item of that response carries a path field and no code.

- `errors` (list of OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaErrorsItems, required)

### 401 Unauthorized Error

Unauthorized. The request token is missing or invalid. The API gateway rejects an unauthenticated call before it reaches Deel; a call that reaches Deel without a valid session is rejected by the access middleware, whose error item carries a message and no code.

- `errors` (list of OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaErrorsItems, required)

### 403 Forbidden Error

Forbidden. The caller lacks the permission to manage child organizations, or at least one submitted id is not a direct child organization of the authenticated organization. The message lists every rejected id. Nothing is written.

- `errors` (list of OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaErrorsItems, required)

### 404 Not Found Error

Operation failed.

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

### 429 Too Many Requests Error

Too many requests. Each partner organization can call this endpoint at most 20 times per hour, with up to 100 admin and child organization pairs per call. Nothing is written; retry once the hour has passed.

- `errors` (list of OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaErrorsItems, required)

### 500 Internal Server Error

An unexpected error occurred before any admin and child organization pair was processed. Nothing is written, and the same request can be retried.

- `errors` (list of OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaErrorsItems, required)

## Types

### OrganizationsChildrenAdminsPostRequestBodyContentApplicationJsonSchemaData

The request payload.

- `admins` (list of OrganizationsChildrenAdminsPostRequestBodyContentApplicationJsonSchemaDataAdminsItems, required) — The people to add as admins of every submitted child organization.
- `child_org_ids` (list of string, required) — Public ids of the target child organizations, as returned in the id field of the create child organization response. Every id must be a direct child organization of the authenticated organization. The number of admins multiplied by the number of child organizations must not exceed 100.

### OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaData

The outcome of the request.

- `items` (list of OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaDataItemsItems, required) — One item per admin and child organization pair of the request.

### OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaErrorsItems

- `code` (string, required) — Machine-readable error code.
- `message` (string, required) — 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

### OrganizationsChildrenAdminsPostRequestBodyContentApplicationJsonSchemaDataAdminsItems

- `email` (string, required) — The email of the person. Each email may appear once per request, ignoring case.
- `last_name` (string, required) — The last name of the person. Used only when the email has no Deel account yet.
- `first_name` (string, required) — The first name of the person. Used only when the email has no Deel account yet.

### OrganizationsChildrenAdminsPostResponsesContentApplicationJsonSchemaDataItemsItems

- `email` (string, required) — The email of the admin, as submitted.
- `status` (enum, required) — The outcome for the pair. ADDED means the person is now an admin of the child organization: a person who was not a member is added with the admin role and receives the invitation email, and a member with another role is made an admin. ALREADY_ADMIN means the person already was, and nothing changed or was sent. FAILED means the pair could not be processed; the other pairs are unaffected and the same request can be retried.
  - Allowed values: `ADDED`, `ALREADY_ADMIN`, `FAILED`
- `child_org_id` (string, required) — The public id of the child organization.

## Examples

**Request**

```json
{
  "data": {
    "admins": [
      {
        "email": "jane.doe@partnercorp.com",
        "last_name": "Doe",
        "first_name": "Jane"
      }
    ],
    "child_org_ids": [
      "8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52"
    ]
  }
}
```

**Response**

```json
{
  "data": {
    "items": [
      {
        "email": "jane.doe@partnercorp.com",
        "status": "ADDED",
        "child_org_id": "8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52"
      }
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.letsdeel.com/rest/organizations/children/admins"

payload = { "data": {
        "admins": [
            {
                "email": "jane.doe@partnercorp.com",
                "last_name": "Doe",
                "first_name": "Jane"
            }
        ],
        "child_org_ids": ["8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52"]
    } }
headers = {
    "X-Beta": "true",
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.letsdeel.com/rest/organizations/children/admins';
const options = {
  method: 'POST',
  headers: {
    'X-Beta': 'true',
    Authorization: 'Bearer <token>',
    'Content-Type': 'application/json'
  },
  body: '{"data":{"admins":[{"email":"jane.doe@partnercorp.com","last_name":"Doe","first_name":"Jane"}],"child_org_ids":["8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52"]}}'
};

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

```go
package main

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

func main() {

	url := "https://api.letsdeel.com/rest/organizations/children/admins"

	payload := strings.NewReader("{\n  \"data\": {\n    \"admins\": [\n      {\n        \"email\": \"jane.doe@partnercorp.com\",\n        \"last_name\": \"Doe\",\n        \"first_name\": \"Jane\"\n      }\n    ],\n    \"child_org_ids\": [\n      \"8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52\"\n    ]\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-Beta", "true")
	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.letsdeel.com/rest/organizations/children/admins")

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

request = Net::HTTP::Post.new(url)
request["X-Beta"] = 'true'
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"admins\": [\n      {\n        \"email\": \"jane.doe@partnercorp.com\",\n        \"last_name\": \"Doe\",\n        \"first_name\": \"Jane\"\n      }\n    ],\n    \"child_org_ids\": [\n      \"8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52\"\n    ]\n  }\n}"

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.letsdeel.com/rest/organizations/children/admins")
  .header("X-Beta", "true")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"data\": {\n    \"admins\": [\n      {\n        \"email\": \"jane.doe@partnercorp.com\",\n        \"last_name\": \"Doe\",\n        \"first_name\": \"Jane\"\n      }\n    ],\n    \"child_org_ids\": [\n      \"8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52\"\n    ]\n  }\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.letsdeel.com/rest/organizations/children/admins', [
  'body' => '{
  "data": {
    "admins": [
      {
        "email": "jane.doe@partnercorp.com",
        "last_name": "Doe",
        "first_name": "Jane"
      }
    ],
    "child_org_ids": [
      "8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52"
    ]
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
    'X-Beta' => 'true',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/organizations/children/admins");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Beta", "true");
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"admins\": [\n      {\n        \"email\": \"jane.doe@partnercorp.com\",\n        \"last_name\": \"Doe\",\n        \"first_name\": \"Jane\"\n      }\n    ],\n    \"child_org_ids\": [\n      \"8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52\"\n    ]\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-Beta": "true",
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["data": [
    "admins": [
      [
        "email": "jane.doe@partnercorp.com",
        "last_name": "Doe",
        "first_name": "Jane"
      ]
    ],
    "child_org_ids": ["8f1d2e3a-4b5f-4a2c-9c4e-1c0e6f1c4a52"]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/organizations/children/admins")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```