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.

Reviewed by Luis Medeiros, Field CTO at ProtofireLast reviewed: November 2026
On this page
Work shipped for 60+ networks and 95+ protocols, including
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.
Custody and tokenizer key
Investor decisions and books
Dapp API
Token, escrow and Sumsub flow
Investment signing
Payment and allowance
Signing service and write queue
Investor sync and booking
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.
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.
White Label Infrastructure "lets organizations offer a platform to their clients under their own brand" (Brickken). Each client issuer has its own tokenizer wallet. So the operator agrees with each client whose custody holds that client's key.
The API lets "a platform issue and operate tokenized real-world assets from its own backend" (Brickken). On the API, the whole write path belongs to your platform. Each write method spends its own credit balance.
Kento connects venues, platforms and protocols to tokens issued on Brickken (Brickken). The venues, platforms and protocols that Kento connects read each token's transfer rules through ERC-7943, and they work with the issuers that choose to enable them. A venue confirms the standard's ERC-165 interface check (EIP) on each token before it relies on that token.
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
- Step 1
Custody test in sandbox
Protofire first tests in sandbox that your custody returns a raw transaction signature for the tokenizer address. - 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. - 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?
Who can build a Brickken integration for an issuer or a tokenization platform?
Can an MPC or HSM custody setup hold the tokenizer key?
Who approves an investor on a Brickken token?
How does our system learn that a Brickken transaction confirmed?
What happens to investor money if a Brickken offering misses its soft cap?
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.
