BIN Sponsor

Novas fontes de receita para o seu negócio.

Crie cartões com a sua marca, utilizando a nossa infraestrutura

Utilizando as nossas licenças e infraestrutura, personalize cartões com a sua marca e entregue uma experiência exclusiva aos seus clientes. Ganhe novas fontes de receita, aprofunde o relacionamento, conheça melhor seu público e amplie o alcance da sua marca.

Sua marca no cartão. Nossa infraestrutura por trás.

BIN Sponsor

Emita cartões de forma descomplicada, utilizando a nossa infraestrutura e as melhores negociações com as bandeiras.

Cartão com a marca da sua empresa

Crie o design e nós cuidamos da produção e entrega. Seu cliente recebe o cartão em poucos dias.

Compatível com carteiras digitais

Permita seu cliente adicionar seu cartão na carteira digital favorita dele como o Apple Pay ou Google Pay.

Escalabilidade e segurança em pagamentos

Oferecemos uma infraestrutura completa, segura e escalável para o processamento de cartões, cobrindo desde a emissão do cartão até o processamento e liquidação das transações.

Embossing

Preparação dos arquivos para as embossadoras, além de parceria para impressão, personalização e entrega dos cartões.

Definição de regras de aprovação

Configure regras flexíveis para gerenciar o uso do cartão, com limites por período, restrições por categoria e bloqueios por país, entre outras regras.

Autorização

Validação das transações em tempo real, com verificação de saldos, limites e regras de uso.

Garantia flexível

Deixe como garantia somente o limite que você utilizará, sem a necessidade de travar capital excedente.

Liquidação

Efetivação e registro financeiro das transações aprovadas.

Conciliação

Conferência das transações entre estabelecimento, processador e bancos emissores, com precisão e transparência.

Chargeback

Gestão completa dos processos de contestação, com acompanhamento e suporte especializado.

Tokenização

Carteiras digitais confiáveis: Apple Pay e Google Pay

Controle de gastos

Estabeleça diversas regras de controle financeiro: defina limites de gastos por período de tempo, restrições por categoria de loja e por país. Você pode configurar limites tanto em Reais (R$) quanto em Dólares (US$). Esse maior controle reduz o risco de fraudes e do mau uso dos seus cartões.

Por que escolher a Stark Infra?

Infraestrutura de processamento robusta e pronta para grandes operações financeiras

Processadora especializada em cartões
Infraestrutura moderna e altamente escalável
Baixa latência e alta disponibilidade
Segurança e conformidade regulatória

Pronto para estruturar sua operação de cartões?

Fale com a Stark Infra e descubra como nossa infraestrutura de processamento de cartões pode sustentar operações financeiras que exigem máxima confiabilidade. A infraestrutura que mantém as operações de cartões rodando o tempo todo.

Developer First

Nós amamos simplicidade. Por isso, nós criamos uma API de infraestrutura bancária confiável, segura e escalável que permite você integrar em apenas alguns minutos. Sua empresa pode testar nossos serviços de forma simples e resolver de uma vez por todas os obstáculos que limitam sua operação financeira.

Python

import starkinfra


cards = starkinfra.issuingcard.create([
    starkinfra.IssuingCard(
        product_id="53810203",
        city="Sao Paulo",
        display_name="ANTHONY STARK",
        district="Bela Vista",
        holder_external_id="my-entity/123",
        holder_name="Tony Stark",
        holder_tax_id="012.345.678-90",
        rules=[
            starkinfra.IssuingRule(
                amount=900000,
                currency_code='BRL',
                interval='week',
                name='Example Rule'
            )
        ],
        state_code="SP",
        street_line_1="Av. Paulista, 200",
        street_line_2="Apto. 123",
        tags=['travel', 'food'],
        zip_code="01311-200"
    )],
    expand=['rules', 'securityCode', 'number', 'expiration'],
)

for card in cards:
    print(card)

Javascript

const starkinfra = require('starkinfra');


(async() => {
    let cards = await starkinfra.issuingCard.create(
        [{
            productId: '53810203',
            city: 'Sao Paulo',
            displayName: 'ANTHONY STARK',
            district: 'Bela Vista',
            holderExternalId: 'my-entity/123',
            holderName: 'Tony Stark',
            holderTaxId: '012.345.678-90',
            rules: [
                new starkinfra.IssuingRule({
                    amount: 900000,
                    currencyCode: 'BRL',
                    interval: 'week',
                    name: 'Example Rule'
                })
            ],
            stateCode: 'SP',
            streetLine1: 'Av. Paulista, 200',
            streetLine2: 'Apto. 123',
            tags: ['travel', 'food'],
            zipCode: '01311-200'
        }],
        {expand: ['rules', 'securityCode', 'number', 'expiration']},
    )

    for await (let card of cards) {
        console.log(card)
    }
})()

PHP

use StarkInfra\IssuingCard;
use StarkInfra\IssuingRule;


$cards = IssuingCard::create(
    [
        new IssuingCard([
            "productId" => "53810203",
            "city" => "Sao Paulo",
            "displayName" => "ANTHONY STARK",
            "district" => "Bela Vista",
            "holderExternalId" => "my-entity/123",
            "holderName" => "Tony Stark",
            "holderTaxId" => "012.345.678-90",
            "rules" => [ 
                new IssuingRule([
                    "amount" => 900000,
                    "currencyCode" => "BRL",
                    "interval" => "week",
                    "name" => "Example Rule"
                ])
            ],
            "stateCode" => "SP",
            "streetLine1" => "Av. Paulista, 200",
            "streetLine2" => "Apto. 123",
            "tags" => ["travel", "food"],
            "zipCode" => "01311-200"
        ])
    ],
    ["expand" => ["rules", "securityCode", "number", "expiration"]]
);

foreach ($cards as $card){
    print_r($card);
}

Java

import com.starkinfra.*; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List;


List<IssuingRule> rules = new ArrayList<>();
HashMap<String, Object> ruleData = new HashMap<>();
ruleData.put("amount", 900000);
ruleData.put("currencyCode", "BRL");
ruleData.put("interval", "week");
ruleData.put("name", "Example Rule");
rules.add(new IssuingRule(ruleData));

List<IssuingCard> cards = new ArrayList<>();
HashMap<String, Object> data = new HashMap<>();
data.put("holderName", "Tony Stark");
data.put("holderTaxId", "012.345.678-90");
data.put("holderExternalId", "my-entity/123");
data.put("displayName", "ANTHONY STARK");
data.put("rules", rules);
data.put("productId", "53810203");
data.put("tags", new String[]{"travel", "food"});
data.put("streetLine1", "Av. Paulista, 200");
data.put("streetLine2", "Apto. 123");
data.put("district", "Bela Vista");
data.put("city", "Sao Paulo");
data.put("stateCode", "SP");
data.put("zipCode", "01311-200");
cards.add(new IssuingCard(data));

HashMap<String, Object> expand = new HashMap<>();
expand.put("expand", new String[] {"rules", "securityCode", "number", "expiration"});

cards = IssuingCard.create(cards, expand);

for (IssuingCard card : cards){
    System.out.println(card);
}

Ruby

require('starkinfra')


cards = StarkInfra::IssuingCard.create(
    cards: [
        StarkInfra::IssuingCard.new(
            product_id: '53810203',
            city: 'Sao Paulo',
            display_name: 'ANTHONY STARK',
            district: 'Bela Vista',
            holder_external_id: 'my-entity/123',
            holder_name: 'Tony Stark',
            holder_tax_id: '012.345.678-90',
            rules: [
                StarkInfra::IssuingRule.new(
                    amount: 900000,
                    currency_code: 'BRL',
                    interval: 'week',
                    name: 'Example Rule'
                )
            ],
            state_code: 'SP',
            street_line_1: 'Av. Paulista, 200',
            street_line_2: 'Apto. 123',
            tags: %w[travel food],
            zip_code: '01311-200'
        )
    ],
    expand: %w[rules securityCode number expiration],
)

cards.each do |card|
    puts card
end

Elixir

cards = StarkInfra.IssuingCard.create!(
    [
        %StarkInfra.IssuingCard{
            holder_name: "Iron Bank S.A.",
            holder_tax_id: "38.606.691/0001-44",
            holder_external_id: "9564",
            rules: [
                %IssuingRule{
                    name: "General",
                    interval: "week",
                    amount: 100000,
                    currency_code: "USD"
                }
            ]
        }
    ],
    expand: ["rules", "securityCode", "number", "expiration"]
)

for card <- cards do
    card |> IO.inspect
end

C#

using System; 
using System.Collections.Generic; 


List<StarkInfra.IssuingCard> cards = StarkInfra.IssuingCard.Create(
    new List<StarkInfra.IssuingCard> {
        new StarkInfra.IssuingCard(
            productId: "53810203",
            city: "Sao Paulo",
            displayName: "ANTHONY STARK",
            district: "Bela Vista",
            holderExternalId: "my-entity/1234",
            holderName: "Tony Stark",
            holderTaxId: "012.345.678-90",
            rules: new List {
                    new StarkInfra.IssuingRule(
                        amount: 900000,
                        currencyCode: "BRL",
                        interval: "week",
                        name: "Example Rule"
                    )
                },
            stateCode: "SP",
            streetLine1: "Av. Paulista, 200",
            streetLine2: "Apto. 123",
            tags: new List { "travel", "food" },
            zipCode: "01311-200"
        )
    },
    new Dictionary<string, object>{
        {"expand", new List { "rules", "securityCode", "number", "expiration" }}
    }
);

foreach (StarkInfra.IssuingCard card in cards)
{
    Console.WriteLine(card);
}

Clojure

Not yet available. Please contact us if you need this SDK.

Curl

curl --location --request POST '{{baseUrl}}/v2/issuing-card?expand=rules,securityCode,number,expiration' \
--header 'Access-Id: {{accessId}}' \ 
--header 'Access-Time: {{accessTime}}' \ 
--header 'Access-Signature: {{accessSignature}}' 
--header 'Content-Type: application/json' \
--data-raw '{
    "cards": [
        {
            "city": "Sao Paulo",
            "displayName": "ANTHONY STARK",
            "district": "Bela Vista",
            "holderExternalId": "7456",
            "holderName": "Jaime Lannister",
            "holderTaxId": "47.151.536/0001-71",
            "rules": [
                {
                    "amount": 900000,
                    "currencyCode": "BRL",
                    "interval": "week",
                    "name": "Example Rule"
                }
            ],
            "stateCode": "SP",
            "streetLine1": "Av. Paulista, 200",
            "streetLine2": "Apto. 123",
            "tags": [
                "travel",
                "food"
            ],
            "zipCode": "01311-200"
        }
    ]
}'