Skip to content

Brickken Integration for Issuers and Tokenization Platforms

Issuers and platforms on Brickken sign each write from their own custody, keep investor records that agree and books that match. Brickken's API leaves that to them, and Protofire builds it. In 2021 we built the DEX core for a KYC-gated DEX, and we have done subgraph and indexer work.

Luis Medeiros

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026

On this page
  1. Overview
  2. Who controls the token
  3. Brickken facts
  4. What you get
  5. Who does what
  6. By Brickken model
  7. Our record
  8. How the project runs
  9. How work starts
  10. Not the right fit
  11. Related guides and services
  12. FAQ

Work shipped for 60+ networks and 95+ protocols, including

  • Chainlink
  • Ethereum
  • Solana
  • Safe
  • Ripple
  • Aave

What Brickken supplies and what your side keeps

A Brickken integration starts with one question: which wallet signs the first write, and can your custody sign for it? Brickken's Dapp API prepares each token, offering and dividend write unsigned. Then your application "reviews it and signs it with your own wallet" (Brickken).

Brickken supplies the token and escrow contracts, a Sumsub identity flow and a sandbox. Investors sign their own investment and claim. Your side keeps the signing, the investor decisions and the books, and Protofire builds that side.

Who handles each part of a Brickken token

Brickken prepares each write, and your signer returns it signed. Brickken returns each outcome when your service asks for it. Investors sign their own investments into the offering escrow.

The issuer

Custody and tokenizer key

The tokenizer wallet signs your mint, whitelist, offering and dividend writes in your own custody, and pays the gas.

Investor decisions and books

You decide which investors may take part, and you keep the register and the general ledger.
Brickken

Dapp API

Brickken prepares unsigned transactions, broadcasts signed ones and answers status reads by txId or hash.

Token, escrow and Sumsub flow

The contracts come from Brickken's factory, and Brickken creates a KYC link per investor email and sends invitation emails.
Investors

Investment signing

Each investor signs newInvest and claimTokens from their own wallet.

Payment and allowance

The investor holds the payment token and approves the escrow of that offering.
Protofire builds

Signing service and write queue

The service hands each prepared transaction to your signer, sends it and polls its txId until the status is success or rejected.

Investor sync and booking

The service joins email, KYC status, your approval and the whitelisted wallet per token, and books token, escrow and dividend movements.

Who controls a Brickken token and who approves its investors

The wallet that runs a token's first newTokenization becomes its tokenizer.Brickken's API guide says that wallet alone can mint, whitelist investors and distribute dividends through the API (Brickken docs). A KMS or MPC signer that is limited to typed data cannot run the default mode. The SDK rejects such a signer locally (SDK). So Protofire tests your custody in sandbox before the token exists. You also ask Brickken in writing how the tokenizer address changes if its key is lost.

Brickken publishes its token, escrow and factory code on GitHub, and that code sets permissions by role. In Brickken's code, the issuer and the offering escrow hold the minter role (Roles.sol). The code also defines roles that Brickken holds. So before launch, you read the role set for your own token together with Brickken. A deployed token may run a later version of that code.

The issuer also makes the investor decision. Brickken's dApp terms make the issuer "solely responsible for determining whether to authorize or restrict participation in a Token Offering" (terms). The same terms say "Brickken does not independently approve, reject, endorse, or verify any Token Buyer(s)". You keep the approval record, and the record shows who recorded each approval and when.

Brickken's token types range from EQUITY and DEBT to REVENUE_SHARE. The issuer's counsel decides which of them is a security, and under which rules.

As powerful as blockchain technology is, it does not have magical abilities to transform the nature of the underlying asset.
Hester M. Peirce, Commissioner, U.S. Securities and Exchange Commission · Statement "Enchanting, but Not Magical: A Statement on the Tokenization of Securities", 9 July 2025

Brickken's role, API and offering rules

Company and role
Brickken Solutions, S.L. is registered in Barcelona. Its terms call it a "Technology Provider" and say it does not act as an intermediary, broker, custodian or financial institution in token activity (terms).
Ways to adopt
Brickken offers Issuer Studio, White Label Infrastructure and the Brickken API (Brickken).
API
The REST API takes an x-api-key on each request, and Brickken provides a TypeScript SDK. Sandbox and production use separate keys and separate databases (docs).
Offerings
Offerings are paid in USDT, USDC or BKN. A token has one ongoing offering at a time. minRaiseUSD is the soft cap, and an offering cannot close early (docs).
Outcomes
Your service polls get-transaction-status by txId or hash. The status is pending, success or rejected (docs).

Checked November 2026 against Brickken's developer documentation, dApp terms and company pages.

What you get from a Brickken integration with Protofire

A tokenizer key that signs in your custody

Protofire builds a signer test with the SDK's canSignTransactions check. So a custody setup that cannot sign fails in sandbox, before the first token exists. Protofire also builds a service that compares chainId, signer and recipients with the request before each signature.

A queue that orders writes and sends each once

Protofire builds a queue that polls each txId and hands a stuck write to your operations lead. The queue holds newSto, mintToken and whitelist until newTokenization is confirmed, so a mint is not sent before the token exists. A pending write is not sent twice, because a second send pays gas twice.

One investor record for KYC, approval and whitelist

KYC is tied to an email, and the whitelist is tied to a wallet. Brickken's docs say "Whitelisting is not KYC" (docs). The first wallet attached to an investor is kept, and Brickken records the wallet once. Protofire builds one record per investor that joins complianceStatus, your approval, the wallet and the whitelist per token. The record flags each mismatch.

Offering raises and refunds booked in your ledger

Your ledger shows the raise or the refund that the escrow produced. The entry uses Brickken's UTC time and your own closing date. Protofire holds closeOffer until endDate and books what follows.

Dividend distributions booked once per holder

Each distribution is booked once per holder, and the entries match Brickken's record. Protofire confirms the payment token's approval to the token contract before Brickken prepares dividendDistribution. We book each distribution by its uuid and txHash.

An alert when an unexpected role holder appears

Your risk team learns of a role change from an alert instead of an audit. Protofire reads the roles on the deployed token and escrow before launch and after each role event. We compare those roles with the set you agreed with Brickken.

Who signs, decides and broadcasts each Brickken write

Brickken broadcasts each signed write unless you chose client-broadcast mode (docs).

Create the token

The issuer: Signs newTokenization from the wallet that becomes the tokenizer

Brickken: Registers the signer address in its factory, then prepares the write

Protofire builds: A signer check, then a read of tokenAddress

KYC and whitelist

The issuer: Decides who may take part, and signs the whitelist per token and wallet

Brickken: Creates a Sumsub link per email and records the wallet once

Protofire builds: A sync into your investor record

Mint

The issuer: Signs mintToken to an investor

Brickken: Sends a new-shareholder invitation on the first mint (docs)

Protofire builds: A check that your own investor notice matches Brickken's

Run an offering

The issuer: Signs newSto, then closeOffer

Brickken: Holds the raise in escrow until close, which ends in success or rollback

Protofire builds: Offering entries in your ledger

Invest and claim

The issuer: Nothing to sign

Brickken: Takes payment, then mints tokens at claim or refunds the payment

Protofire builds: Investor screens, or the hand-off to a custodial platform

Dividends

The issuer: Approves the payment token, then signs dividendDistribution

Brickken: Prepares the distribution and lists it by uuid

Protofire builds: Each distribution booked per holder

What each Brickken model leaves you to build

Issuer Studio "is designed for companies managing their own issuances" (Brickken). The build is small: it covers investor exports into your register and the booking of each mint. An API key gives access to the symbols created under that same key (docs). So an issuer that adds the API later asks Brickken which tokens its key can read.

Our record: a KYC-gated DEX and token event data

Protofire's record covers a venue that admits verified wallets and work that reads chain events as data.

Swarm Markets: a DEX for KYC-verified wallets

In 2021 Protofire built the DEX core (a Balancer fork) and subgraph for Swarm Markets and contributed to dOTC. Swarm Markets was a BaFin-licensed DEX at launch where only KYC-verified wallets trade. Swarm held the license and ran KYC and permissioning. A Brickken whitelist sets the same gate on a token: which wallet is eligible now, and who says so.

The Graph: subgraph writing and indexing

Protofire started writing subgraphs in 2019, and Protofire was a top-3 Graph indexer by indexing rewards, 2020 to 2024 (our subgraph case study). A Brickken integration reads token, escrow and distribution events for the role check and the books. That reading is data work of the same kind.

How a Brickken project with Protofire runs

  1. Step 1

    Custody test in sandbox

    Protofire first tests in sandbox that your custody returns a raw transaction signature for the tokenizer address.
  2. Step 2

    Each write method in sandbox, then production

    Each write method you plan to use is signed and polled in Brickken's sandbox, through the custody setup that production will use. Once Brickken issues a production key and registers your signer address, the first token goes through the queue.
  3. Step 3

    Keys, code and operation after launch

    Your staff hold the tokenizer key and the x-api-key that Brickken issued. The signing service sends the writes that your staff approved or that a rule you signed allows. After launch, Protofire holds no tokenizer key and no role on the token or its escrow. Code that Protofire writes is yours by contract, within the license of third-party software. Your team runs the integration, or Protofire operates a service under a written scope through managed onchain operations. A service that Protofire runs for you reads only: txId polls, investor sync, booking and the role check.

How work with Protofire starts

You send the chain, the token type and your Brickken model.You also name the custody meant to hold the tokenizer key, and your ledger and investor system. Protofire's proposal answers with the signer test, the order of writes and the entries that your books receive. The terms in this section apply as set out on how we work.

Proposal
In writing, one business day after the discovery call: findings, a plan in phases and the first step we recommend.
Price
Fixed per phase when you commission it, against written acceptance criteria. Overruns inside them are ours to absorb, invoices follow delivered milestones, and you can stop at any phase boundary. Anything we operate after launch is priced in the proposal as its own recurring line, with the notice to end it.
Ownership
Code we write for you, contracts, the keys and credentials this work creates and the accounts your infrastructure runs in are yours by contract, within the license of any third-party software involved. Keys that a custody platform or a staking provider holds under its own key model stay with it under your contract; every other custody key stays with you or the custodian you appoint. Where the scope places something on servers we rent, it says what moves to you and when. An NDA is available from your first message, and we sign a data processing agreement (DPA) together with it.
After launch
Delivery closes with a hypercare window and a defect warranty, with their terms written into the proposal. A service we operate continues under its written scope until that scope ends.
Access
Read-only by default. A role that can start requests only if your written scope names one; never a signer, approver, administrator, key holder or recovery role on your contracts, wallets or custody platform. Services we build call each platform on credentials your staff issue and keep in your vault. Anything that approves or moves funds runs in your environment, and a scope under which we operate a service lists every write call it makes. Where the scope has us operate nodes, validators, monitors, explorers or indexers, it names the role and any key we hold on those servers, and in your own cloud account you can remove it.
Licenses
Protofire is an engineering firm and holds no financial or crypto-asset license; licensed activity stays with you and your providers.

How we work shows a worked proposal.

When a Brickken project with Protofire does not fit

Brickken's own tools, or another Protofire service, already cover the job in these four cases.

  • You run one issuance in Issuer Studio, with no custody, register or ledger to connect. The dApp needs no code.
  • You need a branded investor portal and nothing behind it. Brickken's White Label tier delivers the portal itself.
  • You need legal, marketing or financial help for an offering. Brickken's terms describe Expert Collaborators for that help.
  • You want contracts and upgrade keys of your own from day one. Then the work is ERC-3643 development or tokenization infrastructure, because Brickken tokens come from Brickken's factory.

Protofire is an engineering firm and holds no financial or crypto-asset license. You keep the offering, the license and the investor decision.

FAQ

What is a Brickken integration?
A Brickken integration is the engineering around an issuer's side of Brickken's Dapp API. The integration includes a signer for the tokenizer wallet in the issuer's custody. It also includes a queue that polls each write until the status is success or rejected. The integration also covers an investor record that joins KYC and whitelist, and the issuer's books. Protofire builds Brickken integrations for issuers and platforms on Brickken.
Who can build a Brickken integration for an issuer or a tokenization platform?
Protofire, an engineering firm, builds the issuer's own side of a Brickken integration. Protofire builds the signer and the write queue. Protofire also builds the investor sync and the ledger entries. Brickken supplies the token and escrow contracts, the Sumsub flow and the sandbox.
Can an MPC or HSM custody setup hold the tokenizer key?
Yes, an MPC or HSM custody setup can hold the tokenizer key if it can return a raw transaction signature. Brickken's default and client-broadcast modes both need that signature (SDK). Test the exact setup in sandbox first, because the wallet that runs the first newTokenization becomes the tokenizer.
Who approves an investor on a Brickken token?
The issuer approves each investor on a Brickken token. Brickken's dApp terms leave participation to the issuer (terms). The same terms say Brickken does not approve, reject, endorse or verify token buyers. Sumsub returns a check result, and the issuer keeps the approval as a separate record.
How does our system learn that a Brickken transaction confirmed?
Your system learns that a Brickken transaction confirmed by polling. The get-transaction-status endpoint takes the txId or the hash and returns pending, success or rejected (docs). Brickken's docs describe no push notification.
What happens to investor money if a Brickken offering misses its soft cap?
If a Brickken offering misses its soft cap, each investor's claim refunds the payment token. Brickken's docs say that an offering that closes under minRaiseUSD enters rollback (docs). In rollback, claimTokens refunds the payment token instead of releasing tokens. The offering closes after its endDate, and each investor signs their own claim.

Get a proposal

Tell us what you are building. An engineer reads it, we have a short call, and the written proposal follows within one business day.

Luis MedeirosField CTO, reads every request · LinkedIn

A demo or repository link also works.