> This page is for Developer.

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

# Create Super Admins (batch)

POST https://api-b2b.bigcommerce.com/api/v3/io/super-admins/bulk
Content-Type: application/json

Creates new Super Admin users and assign them to BigCommerce channels as provided in the request body. Existing BigCommerce customer accounts will be converted to B2B Edition Super Admin accounts.

In normal conditions, this endpoint supports creation of no more than `10` Super Admins in a single request.

> **NOTE**  
> If there is already a B2B Edition Company user account associated with an email address provided, this endpoint will return with errors, regardless of the role assigned to the B2B Edition Company user account. Existing BigCommerce customer accounts will not throw errors as long as they are not also B2B Edition Company user accounts.

If a user account for a given `email` doesn't currently exist within BigCommerce, it will be created when the request is called. 

Reference: https://docs.bigcommerce.com/developer/api-reference/rest/b2b/management/super-admin/post-super-admins-bulk

## Authentication

- `X-Auth-Token` header (required) — | Header | Argument | Description | |:-------|:---------|:------------| | `X-Auth-Token` | `access_token` | For more about API accounts that generate `access_token`s, see our [Guide to API Accounts](/developer/docs/overview/api-fundamentals/api-accounts). | For example requests and more information about authenticating BigCommerce APIs, see [Authentication and Example Requests](/developer/docs/overview/api-fundamentals/api-accounts#x-auth-token-header-example-requests). For more about BigCommerce OAuth scopes, see our [Guide to API Accounts](/developer/docs/overview/api-fundamentals/api-accounts#oauth-scopes). For a list of API status codes, see [API Status Codes](/developer/api-reference/rest/overview#rest-http-status-codes).
- `X-Store-Hash` header (required) — | Header | Argument | Description | |:-------|:---------|:------------| | `X-Store-Hash` | `store_hash` | The unique store hash associated with a BigCommerce store that has B2B Edition enabled. |

## Request

### Body (application/json)

This endpoint expects a list of SuperAdminsBulkPostRequestBodyContentApplicationJsonSchemaItems.

- `list of SuperAdminsBulkPostRequestBodyContentApplicationJsonSchemaItems`

## Response

### 200

SUCCESS

- `code` (integer, optional, default: 200)
- `data` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaData, optional)
- `meta` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaMeta, optional)

## Errors

### 400 Bad Request Error

BAD REQUEST

- `code` (integer, optional, default: 400)
- `data` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaData, optional)
- `meta` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaMeta, optional)

### 413 Content Too Large Error

REQUEST TOO LARGE

- `code` (integer, optional, default: 413)
- `data` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaData, optional)
- `meta` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaMeta, optional)

### 422 Unprocessable Entity Error

INVALID REQUEST This response is returned when required fields are missing from the request body. See the response data for specific details.

- `code` (integer, optional, default: 422)
- `data` (list of SuperAdminsBulkPostResponsesContentApplicationJsonSchemaDataItems, optional) — An array of objects containing field names with errors and corresponding messages for those errors. Each entry in the array corresponds directly to one of the elements in the response body. > **NOTE** > Only fields for which there are errors will be present in the objects in this list.
- `meta` (SuperAdminsBulkPostResponsesContentApplicationJsonSchemaMeta, optional)

## Types

### SuperAdminsBulkPostRequestBodyContentApplicationJsonSchemaItems

- `channelIds` (list of integer, optional) — An array of unique channel IDs associated with BigCommerce sales channels. The account will only be able to login on channels in this list.
- `email` (string, optional) — The email address associated with the Super Admin's BigCommerce customer account.
- `firstName` (string, optional) — The first name listed on the Super Admin's BigCommerce customer account.
- `lastName` (string, optional) — The last name listed on the Super Admin's BigCommerce customer account.
- `originChannelId` (integer, optional) — The unique BigCommerce channel ID, used for the BigCommerce customer account's origin channel. This field is inactive if the store has a default B2B Edition channel set.
- `phone` (string, optional) — The phone number listed on the Super Admin's BigCommerce customer account.
- `uuid` (string, optional) — An external ID associated with the Super Admin account. B2B Edition does not require UUID to be unique, despite the field's label. B2B Edition will not assign a UUID by default. > NOTE > Some endpoints will only return this field if it has a non-empty value. If your code relies on the presence of a UUID in responses, ensure it is defined for each user, and prefer endpoints that provide more details. > > Regardless of individual user status, make sure to check for existence before attempting to use the value of the `uuid` field.

### SuperAdminsBulkPostResponsesContentApplicationJsonSchemaData

### SuperAdminsBulkPostResponsesContentApplicationJsonSchemaMeta

- `message` (string, optional, default: Parameter Error)

### SuperAdminsBulkPostResponsesContentApplicationJsonSchemaDataItems

- `firstName` (list of string, optional)
- `lastName` (list of string, optional)
- `email` (list of string, optional)

## Examples

**Request**

```json
[
  {
    "email": "marie.curie@example.com",
    "firstName": "Marie",
    "lastName": "Curie"
  }
]
```

**Response**

```json
{
  "code": 200,
  "data": {
    "superAdminIds": [
      123456
    ]
  },
  "meta": {
    "message": "Success"
  }
}
```

**SDK Code**

```python
import requests

url = "https://api-b2b.bigcommerce.com/api/v3/io/super-admins/bulk"

payload = [
    {
        "email": "marie.curie@example.com",
        "firstName": "Marie",
        "lastName": "Curie"
    }
]
headers = {
    "X-Auth-Token": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api-b2b.bigcommerce.com/api/v3/io/super-admins/bulk';
const options = {
  method: 'POST',
  headers: {'X-Auth-Token': '<apiKey>', 'Content-Type': 'application/json'},
  body: '[{"email":"marie.curie@example.com","firstName":"Marie","lastName":"Curie"}]'
};

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-b2b.bigcommerce.com/api/v3/io/super-admins/bulk"

	payload := strings.NewReader("[\n  {\n    \"email\": \"marie.curie@example.com\",\n    \"firstName\": \"Marie\",\n    \"lastName\": \"Curie\"\n  }\n]")

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

	req.Header.Add("X-Auth-Token", "<apiKey>")
	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-b2b.bigcommerce.com/api/v3/io/super-admins/bulk")

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

request = Net::HTTP::Post.new(url)
request["X-Auth-Token"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "[\n  {\n    \"email\": \"marie.curie@example.com\",\n    \"firstName\": \"Marie\",\n    \"lastName\": \"Curie\"\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-b2b.bigcommerce.com/api/v3/io/super-admins/bulk")
  .header("X-Auth-Token", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("[\n  {\n    \"email\": \"marie.curie@example.com\",\n    \"firstName\": \"Marie\",\n    \"lastName\": \"Curie\"\n  }\n]")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-b2b.bigcommerce.com/api/v3/io/super-admins/bulk', [
  'body' => '[
  {
    "email": "marie.curie@example.com",
    "firstName": "Marie",
    "lastName": "Curie"
  }
]',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-Auth-Token' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api-b2b.bigcommerce.com/api/v3/io/super-admins/bulk");
var request = new RestRequest(Method.POST);
request.AddHeader("X-Auth-Token", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"email\": \"marie.curie@example.com\",\n    \"firstName\": \"Marie\",\n    \"lastName\": \"Curie\"\n  }\n]", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-Auth-Token": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  [
    "email": "marie.curie@example.com",
    "firstName": "Marie",
    "lastName": "Curie"
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-b2b.bigcommerce.com/api/v3/io/super-admins/bulk")! 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()
```