mintToken

Prepare a token mint

curl --request POST \
  --url https://api.sandbox.brickken.com/prepare-transactions \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "method": "mintToken",
  "chainId": "aa36a7",
  "signerAddress": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
  "tokenSymbol": "EXMPL",
  "userToMint": [
    {
      "investorEmail": "investor@example.com",
      "investorAddress": "0x1111111111111111111111111111111111111111",
      "amount": "100",
      "needWhitelist": true
    }
  ]
}
'

import requests

url = "https://api.sandbox.brickken.com/prepare-transactions"

payload = {
    "method": "mintToken",
    "chainId": "aa36a7",
    "signerAddress": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    "tokenSymbol": "EXMPL",
    "userToMint": [
        {
            "investorEmail": "investor@example.com",
            "investorAddress": "0x1111111111111111111111111111111111111111",
            "amount": "100",
            "needWhitelist": True
        }
    ]
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

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

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    method: 'mintToken',
    chainId: 'aa36a7',
    signerAddress: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
    tokenSymbol: 'EXMPL',
    userToMint: [
      {
        investorEmail: 'investor@example.com',
        investorAddress: '0x1111111111111111111111111111111111111111',
        amount: '100',
        needWhitelist: true
      }
    ]
  })
};

fetch('https://api.sandbox.brickken.com/prepare-transactions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.brickken.com/prepare-transactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'method' => 'mintToken',
    'chainId' => 'aa36a7',
    'signerAddress' => '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
    'tokenSymbol' => 'EXMPL',
    'userToMint' => [
        [
                'investorEmail' => 'investor@example.com',
                'investorAddress' => '0x1111111111111111111111111111111111111111',
                'amount' => '100',
                'needWhitelist' => true
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.sandbox.brickken.com/prepare-transactions"

	payload := strings.NewReader("{\n  \"method\": \"mintToken\",\n  \"chainId\": \"aa36a7\",\n  \"signerAddress\": \"0x742d35Cc6634C0532925a3b844Bc454e4438f44e\",\n  \"tokenSymbol\": \"EXMPL\",\n  \"userToMint\": [\n    {\n      \"investorEmail\": \"investor@example.com\",\n      \"investorAddress\": \"0x1111111111111111111111111111111111111111\",\n      \"amount\": \"100\",\n      \"needWhitelist\": true\n    }\n  ]\n}")

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

	req.Header.Add("x-api-key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.sandbox.brickken.com/prepare-transactions")
  .header("x-api-key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"method\": \"mintToken\",\n  \"chainId\": \"aa36a7\",\n  \"signerAddress\": \"0x742d35Cc6634C0532925a3b844Bc454e4438f44e\",\n  \"tokenSymbol\": \"EXMPL\",\n  \"userToMint\": [\n    {\n      \"investorEmail\": \"investor@example.com\",\n      \"investorAddress\": \"0x1111111111111111111111111111111111111111\",\n      \"amount\": \"100\",\n      \"needWhitelist\": true\n    }\n  ]\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.sandbox.brickken.com/prepare-transactions")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"method\": \"mintToken\",\n  \"chainId\": \"aa36a7\",\n  \"signerAddress\": \"0x742d35Cc6634C0532925a3b844Bc454e4438f44e\",\n  \"tokenSymbol\": \"EXMPL\",\n  \"userToMint\": [\n    {\n      \"investorEmail\": \"investor@example.com\",\n      \"investorAddress\": \"0x1111111111111111111111111111111111111111\",\n      \"amount\": \"100\",\n      \"needWhitelist\": true\n    }\n  ]\n}"

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

{
  "transactions": [
    {
      "from": "0x1234567890abcdef1234567890abcdef12345678",
      "to": "0xabcdef1234567890abcdef1234567890abcdef12",
      "value": "0x00",
      "nonce": 3792,
      "chainId": 11155111,
      "data": "0xd362e8a70000000000000000000000000000000000000000000000000000000000000040...",
      "type": 2,
      "maxPriorityFeePerGas": "1150000",
      "maxFeePerGas": "1156037",
      "gasLimit": "0xccef"
    }
  ],
  "txId": "0x46adea7bdf49c576a760102e0d6bc9ecd650b3998588cd3d7f576a7973426aad",
  "info": {
    "tokenizerEmail": "tokenizer@example.com",
    "tokenSymbol": "EXMPL",
    "investorEmail": "investor@example.com"
  }
}

POST

prepare-transactions

Prepare a token mint

curl --request POST \
  --url https://api.sandbox.brickken.com/prepare-transactions \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "method": "mintToken",
  "chainId": "aa36a7",
  "signerAddress": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
  "tokenSymbol": "EXMPL",
  "userToMint": [
    {
      "investorEmail": "investor@example.com",
      "investorAddress": "0x1111111111111111111111111111111111111111",
      "amount": "100",
      "needWhitelist": true
    }
  ]
}
'

import requests

url = "https://api.sandbox.brickken.com/prepare-transactions"

payload = {
    "method": "mintToken",
    "chainId": "aa36a7",
    "signerAddress": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    "tokenSymbol": "EXMPL",
    "userToMint": [
        {
            "investorEmail": "investor@example.com",
            "investorAddress": "0x1111111111111111111111111111111111111111",
            "amount": "100",
            "needWhitelist": True
        }
    ]
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

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

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    method: 'mintToken',
    chainId: 'aa36a7',
    signerAddress: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
    tokenSymbol: 'EXMPL',
    userToMint: [
      {
        investorEmail: 'investor@example.com',
        investorAddress: '0x1111111111111111111111111111111111111111',
        amount: '100',
        needWhitelist: true
      }
    ]
  })
};

fetch('https://api.sandbox.brickken.com/prepare-transactions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.sandbox.brickken.com/prepare-transactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'method' => 'mintToken',
    'chainId' => 'aa36a7',
    'signerAddress' => '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
    'tokenSymbol' => 'EXMPL',
    'userToMint' => [
        [
                'investorEmail' => 'investor@example.com',
                'investorAddress' => '0x1111111111111111111111111111111111111111',
                'amount' => '100',
                'needWhitelist' => true
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.sandbox.brickken.com/prepare-transactions"

	payload := strings.NewReader("{\n  \"method\": \"mintToken\",\n  \"chainId\": \"aa36a7\",\n  \"signerAddress\": \"0x742d35Cc6634C0532925a3b844Bc454e4438f44e\",\n  \"tokenSymbol\": \"EXMPL\",\n  \"userToMint\": [\n    {\n      \"investorEmail\": \"investor@example.com\",\n      \"investorAddress\": \"0x1111111111111111111111111111111111111111\",\n      \"amount\": \"100\",\n      \"needWhitelist\": true\n    }\n  ]\n}")

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

	req.Header.Add("x-api-key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.sandbox.brickken.com/prepare-transactions")
  .header("x-api-key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"method\": \"mintToken\",\n  \"chainId\": \"aa36a7\",\n  \"signerAddress\": \"0x742d35Cc6634C0532925a3b844Bc454e4438f44e\",\n  \"tokenSymbol\": \"EXMPL\",\n  \"userToMint\": [\n    {\n      \"investorEmail\": \"investor@example.com\",\n      \"investorAddress\": \"0x1111111111111111111111111111111111111111\",\n      \"amount\": \"100\",\n      \"needWhitelist\": true\n    }\n  ]\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.sandbox.brickken.com/prepare-transactions")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"method\": \"mintToken\",\n  \"chainId\": \"aa36a7\",\n  \"signerAddress\": \"0x742d35Cc6634C0532925a3b844Bc454e4438f44e\",\n  \"tokenSymbol\": \"EXMPL\",\n  \"userToMint\": [\n    {\n      \"investorEmail\": \"investor@example.com\",\n      \"investorAddress\": \"0x1111111111111111111111111111111111111111\",\n      \"amount\": \"100\",\n      \"needWhitelist\": true\n    }\n  ]\n}"

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

{
  "transactions": [
    {
      "from": "0x1234567890abcdef1234567890abcdef12345678",
      "to": "0xabcdef1234567890abcdef1234567890abcdef12",
      "value": "0x00",
      "nonce": 3792,
      "chainId": 11155111,
      "data": "0xd362e8a70000000000000000000000000000000000000000000000000000000000000040...",
      "type": 2,
      "maxPriorityFeePerGas": "1150000",
      "maxFeePerGas": "1156037",
      "gasLimit": "0xccef"
    }
  ],
  "txId": "0x46adea7bdf49c576a760102e0d6bc9ecd650b3998588cd3d7f576a7973426aad",
  "info": {
    "tokenizerEmail": "tokenizer@example.com",
    "tokenSymbol": "EXMPL",
    "investorEmail": "investor@example.com"
  }
}

Prepares unsigned transactions for minting tokens to specified users. Use POST /prepare-transactions with method=mintToken. Minting increases the token’s current totalSupply and the recipient’s balance. It does not change the configured maximum supply.

Recipient Requirements

Every entry in userToMint needs a valid investorEmail and a positive whole-token amount.
investorEmail must be different from the token’s tokenizerEmail. Issuer and investor are separate email identities, even when they use the same wallet for sandbox testing. A collision returns investorEmail cannot be the tokenizer email (index N), where N is the position in userToMint.
Use the exact symbol from a successfully confirmed newTokenization. A symbol that does not resolve on the supplied chain returns No company found with this token symbol.
needWhitelist only determines whether the recipient is whitelisted with the mint. It does not change the identity requirement. It defaults to true unless explicitly set to false.
needKyc on a userToMint entry works the same way it does on whitelist, and false is accepted in Sandbox only.

Testing in Sandbox? Pass needKyc: false and skip identity verification entirely. The KYC flow is a Sumsub verification with document upload, not something you need to prove your integration works, and every test investor you create without it is one less manual step in your loop.Rehearse the real KYC flow once before you go live, since needKyc: false is rejected in production with needKyc=false is only available in the sandbox environment.

This method is an issuance-to-investors flow. It cannot mint to the tokenizer’s own identity, so there is no supported payload for minting into a company treasury.

Response shape

transactions is an array, as it is for every other prepare method. Iterate it rather than assuming a single entry: when a recipient still needs whitelisting, the response carries two transactions. When no recipient needs whitelisting:

{
  "transactions": [ { "…unsigned mint transaction…" } ],
  "info": { "…" },
  "txId": "0x…"
}

When at least one recipient still needs whitelisting, the whitelist transaction comes first and txId carries the matching identifiers in the same order:

{
  "transactions": [
    { "…unsigned whitelist transaction…" },
    { "…unsigned mint transaction…" }
  ],
  "info": { "…" },
  "txId": ["0x…", "0x…"]
}

Sign and send all of them, in order, and wait for each to succeed before the next. The transactions carry sequential nonces, so broadcasting only the mint leaves it on a nonce that will never be used: it never mines, and the tokens never exist. A later burnToken or balance read then correctly reports no balance, which looks like an indexing lag but is not one.

Credits

Two independent counters can block a mint:

API-key mint credits, consumed once per mint operation at send time. Exhausting them returns Out of credits for minting.
License mint-recipient credits, counted per distinct recipient. Exhausting them returns Mint credit limit exceeded.

A recipient email that has never been invited also consumes an invitation credit; exhausting those returns Invitation credit limit exceeded. When more than one counter is exhausted the message lists them, for example Insufficient license credits: mint, invitation. None of these have a public reset endpoint. Contact support@brickken.com to review an account’s balances.

The first mint to a new recipient sends both a new-shareholder invitation and a token-received notification. Later mints to the same recipient send only the token-received notification.

Next step

Preparing does not touch the chain. The response gives you txId and an array of unsigned transactions — you still have to sign and submit them.

Sign every returned transaction

Sign each entry locally with the wallet that sends the transaction — signerAddress, or investorAddress for newInvest and claimTokens. It must be whitelisted by Brickken, and it needs native gas on the target chain.

Submit the signed payloads

POST them to /send-transactions as { txId, signedTransactions } and Brickken broadcasts for you.If you would rather broadcast yourself, prepare with executionMode: "client-broadcast" and confirm afterwards with { txId, txHash } instead.

Poll until it confirms

Call GET /get-transaction-status with the txId. A pending status means it is broadcast but not yet mined — do not resubmit.

Full walkthrough: Tokenize an asset and run an STO.

Authorizations

x-api-key

string

header

required

Body

application/json

method

enum<string>

default:mintToken

required

Required. Operation to prepare. Must be mintToken for this endpoint.

Available options:

mintToken

Example:

"mintToken"

chainId

string

required

Required. Blockchain network identifier. Hex format is recommended, for example Sepolia aa36a7.

Example:

"aa36a7"

signerAddress

string

required

Required. Tokenizer wallet that signs the mint transaction, and the whitelist transaction when recipients still need whitelisting.

Example:

"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"

tokenSymbol

string

required

Required. Symbol of the token to mint. Its chainId must match the one in this request.

Example:

"EXMPL"

userToMint

object[]

required

Required. Users to mint tokens to.

Minimum array length: 1

Show child attributes

Example:

[
  {
    "investorEmail": "investor@example.com",
    "investorAddress": "0x1111111111111111111111111111111111111111",
    "amount": "100",
    "needWhitelist": true
  }
]

Response

200 - application/json

Successful response

transactions

object[]

required

Unsigned transactions ready for signing, in the order they must be broadcast. Contains two entries when a recipient still needs whitelisting: the whitelist transaction first, then the mint.

Show child attributes

txId

required

Identifier for this prepared transaction, required by /send-transactions. When transactions holds more than one entry this is an array of identifiers in the same order. This is NOT a blockchain transaction hash.

Example:

"0x46adea7bdf49c576a760102e0d6bc9ecd650b3998588cd3d7f576a7973426aad"

info

object

Metadata about the operation

Show child attributes

Overview

Guides

Prepare Transactions

Send Transactions

Read Endpoints

Token Documents

KYC

Recipient Requirements

Response shape

Credits

Next step

Authorizations

Body

Response

​Recipient Requirements

​Response shape

​Credits

​Next step

Authorizations

Body

Response

Recipient Requirements

Response shape

Credits

Next step