.card a:not(.card) {
    border-bottom: 1.5px solid #C3F4EF;
    ;
    font-weight: 600;
}

.card a:not(.card):hover {
    border-bottom: 2px solid #C3F4EF;
    ;
}

html:not(.dark) .card a:not(.card) {
    color: var(--tw-prose-links);
    min-width: 1em !important
}


/* The following code is a workaround for theming Mintlify docs correctly. */
/* As they do not support fully customized theming, we need to overwrite   */
/* css classes                                                             */
/*                                                                         */
/* See Figma for reference:
/* [https://www.figma.com/design/plALoHUzhePk7A2c4WCoFN/[Lego]-Jornada-PLG?node-id=887-1100&t=7Zr19nkRzV0S4ik9-0] */

:root {
    /* Defining Malga Colors */
    --malgreen-200: #BAE7C9;
    --malgreen-300: #38BFAD;
    --malgreen-400: #2FAC9B;
    --malblack-100: #666666;
    --malblack-200: #4D4D4D;
    --malblack-300: #333333;
    --malblack-400: #1A1A1A;
    --malwhite-100: #FFFFFF;
    --malwhite-200: #F9F9F9;
    --malwhite-300: #F1F1F1;
    --malwhite-500: #CBCBCB;
    --malred-200: #FFA4B3;
    --malinfo-100: #E1EEF4;
    --malinfo-300: #3C8DDD;
    --malinfo-400: #1e61b6;
    --malsuccess-100: #e4f2e8;
    --malsuccess-200: #bae7c9;
    --malsuccess-300: #00ae42;
    --malsuccess-400: #009033;
    --malsuccess-500: #00601B;
    --malwarning-100: #FFF8E6;
    --malwarning-200: #F9DF8D;
    --malwarning-300: #FFA400;
    --malwarning-400: #F0941A;
    --malwarning-500: #D47129;
    --malerror-100: #ffd2dc;

    --post-bg: #3C8DDD;
    --get-bg: #009033;
    --patch-bg: #F0941B;
    --delete-bg: #D12E2d;
}

/* General Titles and Subtitles in Light Mode and Dark Mode */

.text-gray-900,
.text-gray-800,
.text-gray-700 {
    color: var(--malblack-400);
}

.text-primary {
    color: var(--malgreen-400);
}

.prose :where(h1, h2, h3, h4, h5, h6):not(:where([class~=not-prose] *)) {
    color: var(--malblack-400);
}

.prose :where(h1, h2, h3, h4, h5, h6):where([class=dark] *):not(:where([class~=not-prose] *)) {
    color: var(--malwhite-200);
}

.prose :where(thead th):not(:where([class~=not-prose] *)) {
    color: var(--malblack-100)
}

:is(.dark .prose :where(thead th):not(:where([class~=not-prose] *))) {
    color: var(--malwhite-500)
}

:is(.dark .prose :is(h1, h2, h3, h4, h5, h6)) {
    color: var(--malwhite-200);
}

.text-gray-600 {
    color: var(--malblack-200);
}

.text-gray-500 {
    color: var(--malblack-100);
}

.text-gray-200 {
    color: var(--malwhite-200);
}

.text-gray-400 {
    color: var(--malwhite-500);
}

.z-10 {
    color: var(--malgreen-300)
}

.prose {
    color: var(--malblack-100);
}

:is(.dark .prose) {
    color: var(--malwhite-500);
}

:is(.dark .dark\:text-gray-200) {
    color: var(--malwhite-200);
}

:is(.dark .dark\:text-gray-400) {
    color: var(--malwhite-500);
}


:is(.dark .dark\:text-primary-light) {
    --tw-text-opacity: 1;
    color: var(--malgreen-300);
}

/*CTA "Quero Testar" */
:is(.dark #topbar-cta-button .dark\:bg-primary-light\/10) {
    background-color: var(--malgreen-400);
}

/* Navbar and Arrow */
#navbar .text-gray-600 {
    color: var(--malblack-100);
}

#sidebar li .text-gray-600 {
    color: var(--malblack-100);
}

#sidebar li .text-gray-700 {
    color: var(--malblack-100);
}

#sidebar li .bg-primary\/10 {
    background-color: rgba(47, 172, 155, 0.1);
    color: var(--malgreen-400);
}

:is(.dark #sidebar li .text-gray-600) {
    color: var(--malwhite-500) !important;
}

:is(.dark #sidebar .dark\:text-gray-200) {
    color: var(--malwhite-300);
}

:is(.dark #sidebar li .text-gray-700) {
    color: var(--malwhite-500) !important;
}

:is(.dark #navbar .dark\:text-gray-400) {
    color: var(--malwhite-500) !important;
}

:is(.dark #navbar .dark\:text-primary-light) {
    color: var(--malwhite-100);
}

/* Table of Contents */
:is(.dark #table-of-contents .text-primary) {
    color: var(--malgreen-400);
}

/* Cards */
.card .text-gray-600 {
    color: var(--malblack-100);
}

:is(.dark .card .dark\:text-gray-400) {
    color: var(--malwhite-500);
}

:is(.dark .card h2) {
    color: var(--malwhite-200);
}

/* Api Reference */

/*botão post clicado light mode*/
.bg-\[\#3064E3\] {
    background-color: var(--malinfo-400);
    color: var(--malwhite-100);
}

/*botão post clicado dark mode*/
:is(.dark .bg-\[\#3064E3\]) {
    background-color: var(--malinfo-300);
}

.text-white {
    color: var(--malwhite-100);
}

/*botão post não clicado darkmode*/
:is(.dark .dark\:bg-blue-400\/20) {
    color: var(--malinfo-300);
}

/*botão post não clicado lightmode*/
.bg-blue-400\/20 {
    background-color: var(--malinfo-100);
    color: var(--malinfo-400);
}

.bg-\[\#2AB673\] {
    background-color: var(--get-bg);
}

.bg-\[\#DA622B\] {
    background-color: var(--patch-bg);
}

.bg-\[\#CB3A32\] {
    background-color: var(--delete-bg);
}

.bg-green-400\/20 {
    background-color: var(--malsuccess-100);
    color: var(--get-bg);
}

:is(.dark .dark\:text-green-400) {
    color: var(--malsuccess-300)
}

.bg-orange-400\/20 {
    background-color: var(--malwarning-100);
    color: var(--patch-bg);
}

:is(.dark .dark\:text-orange-400) {
    color: var(--malwarning-300)
}

.bg-red-400\/20 {
    background-color: var(--malerror-100);
    color: var(--delete-bg);
}

:is(.dark .dark\:text-red-400) {
    color: var(--malred-200)
}

/* Icons */
:is(.dark .dark\:bg-primary-light) {
    background-color: var(--malgreen-400);
}

.stroke-gray-400 {
    stroke: var(--malgreen-400);
}

/* Tip */
.border-emerald-500\/20 {
    border-color: var(--malgreen-200);
}

.bg-emerald-50\/50 {
    background-color: var(--malsuccess-100);
}

.bg-emerald-50\/50 .text-emerald-900 {
    color: var(--malsuccess-500);
}

.bg-emerald-50\/50 svg.text-emerald-600 {
    color: var(--malsuccess-400);
}

:is(.dark svg.text-emerald-600) {
    color: var(--malsuccess-200);
}

:is(.dark .dark\:text-emerald-200) {
    color: var(--malsuccess-200);
}

/* Warning */
.border-amber-500\/20 {
    border-color: var(--malwarning-200);
}

.bg-amber-50\/50 {
    background-color: var(--malwarning-100);
}

.bg-amber-50\/50 .text-amber-900 {
    color: var(--malwarning-500);
}

.bg-amber-50\/50 svg.text-amber-400 {
    stroke: var(--malwarning-400);
}

:is(.dark .dark\:text-amber-200) {
    color: var(--malwarning-200);
}

:is(.dark svg.text-amber-400) {
    stroke: var(--malwarning-300);
}

.malga-icon-box .malga-icon[id="sodexo"],
.malga-icon-box .malga-icon[id="visa"],
.malga-icon-box .malga-icon[id="master"],
.malga-icon-box .malga-icon[id="amex"],
.malga-icon-box .malga-icon[id="dinners"],
.malga-icon-box .malga-icon[id="discover"],
.malga-icon-box .malga-icon[id="jcb"],
.malga-icon-box .malga-icon[id="vr"],
.malga-icon-box .malga-icon[id="elo"] {
    width: 55px !important;
    height: 55px !important;
}

/* Tables  */
.prose tbody tr:nth-child(odd) {
    background-color: var(--malwhite-200);
}

:is(.dark .prose tbody tr:nth-child(odd)) {
    background-color: var(--malblack-400);
}

td:is(:first-child) {     
    padding-left: 8px;
}

td:is(:last-child) {
    padding-right: 8px;
}

td {
    vertical-align: middle !important;
}

td[align="center"] {
    text-align: center;
    vertical-align: middle !important;
}

td[align="left"] {
    text-align: left;
    vertical-align: middle !important;
}

td[align="right"] {
    text-align: right;
    vertical-align: middle !important;
}

td > span {
    height: 36px !important;
}

/* Check Icon Badge Dark Mode */
:is(.dark .prose :where(.malga-check-badge):not(:where([class~=not-prose] *))) {
    background-color: var(--malblack-300);
}

.check-icon > p {
    margin: 0 !important;
}

.table-legend > p {
    font-size: 12px;
    margin: 0;
}

.mx-1 {
    margin: 0 1em;
}

import { readFileSync, writeFileSync } from "node:fs";
import {
  getProviderFileName,
  unsupportedByProvider,
  handleCapabilities,
  moveSandboxToFirst,
} from "./utils.js";

import Mustache from "mustache";
import * as fsExtra from "fs-extra";

const basePath = "documentations/providers";

export function generateProvidersDocs(providers) {
  fsExtra.emptyDirSync(basePath);

  const creditTemplate = readFileSync(
    "scripts/generate-providers/templates/credit-provider-documentation.txt",
    "utf8"
  );

  const defaultTemplate = readFileSync(
    "scripts/generate-providers/templates/provider-documentation.txt",
    "utf8"
  );

  const providersList = Object.values(providers);
  moveSandboxToFirst(providersList);

  const providersToRemove = ["Rede", "Itaú"];

  const generatedFiles = providersList
    .filter((provider) => !providersToRemove.includes(provider.name))
    .filter((provider) => provider.documentation)
    .map((provider) => {
      const hasOnlyCredit = checkIfProviderHasOnlyCredit(provider);

      const template = hasOnlyCredit ? creditTemplate : defaultTemplate;
      const output = Mustache.render(template, handleProvider(provider));

      const fileName = getProviderFileName(provider.name);

      const filePath = `${basePath}/${fileName}`;
      writeFileSync(`${filePath}.mdx`, output);

      return filePath;
    });

  return generatedFiles;
}

function checkIfProviderHasOnlyCredit(provider) {
  const hasCredit =
    provider.paymentMethods?.creditCard !== unsupportedByProvider &&
    provider.paymentMethods?.creditCard !== false;

  const dontHaveAnyOtherMethod = Object.entries(provider.paymentMethods).some(
    ([key, value]) => {
      if (key === "creditCard") {
        return false;
      }

      return value === unsupportedByProvider || value === false;
    }
  );

  return hasCredit && dontHaveAnyOtherMethod;
}

function handleProvider(provider) {
  const hasSplit = provider.paymentMethods?.creditCard?.hasSplit === true;
  const has3ds = provider.paymentMethods?.creditCard?.has3ds === true;
  const hasWallet = provider.paymentMethods?.creditCard?.wallet === true;
  const hasPixParcelado = provider.paymentMethods?.pixParcelado === true;
  const hasMalga3ds = provider.paymentMethods?.creditCard?.hasMalga3ds === true;

  return {
    name: provider.name,
    type: handleType(provider.connectionType),
    description: provider.documentation?.description,
    docUrl: provider.documentation?.documentationUrl,
    handleCapabilities: () => {
      return (templateArgument) =>
        handleCapabilities(provider, templateArgument);
    },
    hasSplit,
    has3ds,
    hasWallet,
    hasPixParcelado,
    hasMalga3ds,
    hasAnyServices:
      hasSplit || has3ds || hasWallet || hasPixParcelado || hasMalga3ds,
  };
}

function handleType(type) {
  const types = {
    "payment-connection": "Provedor de pagamento",
    "antifraud-connection": "Provedor de antifraude",
    "payment-method": "Método de pagamento",
  };

  return types[type];
}


import { readFileSync, writeFileSync } from "node:fs";
import {
  getProviderFileName,
  iconType,
  unsupportedByProvider,
  handleCapabilities,
  moveSandboxToFirst,
} from "./utils.js";

import Mustache from "mustache";

export function generateProvidersTable(providers) {
  const template = readFileSync(
    "scripts/generate-providers/templates/providers-table.txt",
    "utf8"
  );

  const providersToRemove = ["Rede", "Itaú"];

  const providersList = Object.values(providers)
    .filter((provider) => !providersToRemove.includes(provider.name))
    .filter((provider) => provider.documentation)
    .map((provider) => {
      const providerFileName = getProviderFileName(provider.name);
      const docUrl = `/documentations/providers/${providerFileName}`;

      return {
        icon: provider.documentation?.icon,
        iconBackgroundColor: provider.documentation?.iconBackgroundColor,
        name: provider.name,
        docUrl: docUrl,
        providerType: provider.providerType,
        handleServices: () => {
          const icons = [
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.hasSplit",
              "Split"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.has3ds",
              "3DS2"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.wallet",
              "Wallet"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.pixParcelado",
              "Pix Parcelado"
            ),
            ...handleServicesIcon(
              provider,
              "paymentMethods.creditCard.hasMalga3ds",
              "3DS2 Malga"
            ),
          ];

          if (!icons.length) {
            return "";
          }

          const checks = icons.join("");

          return `<div className="flex flex-row gap-2">${checks}</div>`;
        },
        handleCapabilities: () => {
          return (templateArgument) =>
            handleCapabilities(provider, templateArgument);
        },
      };
    });

  moveSandboxToFirst(providersList);

  const output = Mustache.render(template, { providers: providersList });
  const filePath =
    "documentations/type-tables/payment-methods-by-providers.mdx";

  writeFileSync(filePath, output);

  return "documentations/type-tables/payment-methods-by-providers";
}

function handleServicesIcon(provider, service, serviceName) {
  const features = service.split(".");
  const providerService = features.reduce((acc, feature) => {
    return acc?.[feature];
  }, provider);

  const isUnsupportedByProvider = providerService === unsupportedByProvider;

  if (isUnsupportedByProvider || !providerService) {
    return [];
  }

  const icon = iconType[true];

  return [`<CheckIconBadge ${icon}>${serviceName}</CheckIconBadge>`];
}


import { generateProvidersDocs } from "./generate-providers-docs.js";
import { generateProvidersTable } from "./generate-providers-table.js";
import { updateMintFile } from "./update-mint-file.js";

import Mustache from "mustache";

const providers = await fetch(
  "https://malga-providers.s3.amazonaws.com/providers.json"
).then((res) => res.json());

Mustache.escape = (str) => str;

const generatedTableFile = generateProvidersTable(providers);
const generatedDocs = generateProvidersDocs(providers);

const generatedFiles = [generatedTableFile, ...generatedDocs];

updateMintFile(generatedFiles);


import { readFileSync, writeFileSync } from "node:fs";

export function updateMintFile(files) {
  const mint = readFileSync("mint.json", "utf8");
  const mintJson = JSON.parse(mint);

  mintJson.navigation
    .find((e) => e.group === "Conexões")
    .pages.find((e) => e.group === "Provedores de pagamento").pages =
    files;

  writeFileSync("mint.json", JSON.stringify(mintJson), "utf8");
}


export const unsupportedByProvider = "unsupported-by-provider";

export const iconType = {
  true: `type="check" mode="success"`,
  false: `type="check" mode="noSupported"`,
  unsupportedByProvider: `type="xmark" mode="error"`,
};

export function getProviderFileName(providerName) {
  return providerName
    .replaceAll(/\./g, "")
    .replaceAll(" ", "-")
    .normalize("NFD")
    .replaceAll(/[\p{Diacritic}]/gu, "")
    .toLowerCase();
}

export function moveSandboxToFirst(providers) {
  const indexOfSandbox = providers.findIndex((provider) =>
    provider.providerType?.includes("SANDBOX")
  );
  const sandboxProvider = providers[indexOfSandbox];

  providers.splice(indexOfSandbox, 1);

  providers.unshift(sandboxProvider);
}

export function handleCapabilities(provider, templateArgument) {
  const features = templateArgument.split(".");

  const capability = features.reduce((acc, feature) => {
    return acc?.[feature];
  }, provider);

  if (!capability) {
    return iconType[false];
  }

  if (capability === unsupportedByProvider) {
    return iconType.unsupportedByProvider;
  }

  return iconType[true];
}


Funções por métodos de pagamento suportados

Dashboard

Nosso Blog

Status Page

Malga

Documentação

SDKs

Referência da API

Analytics

Release Notes

Quero testar

Suporte

Stripe

Sobre a Malga

Sobre o produto

Primeiros passos

Autenticação

Guia de teste

Tratamento de erros

Ativando sua conta

Introdução

Cartão de crédito

Boleto

NuPay

Picpay

Drip

Voucher

Sandbox

Adyen

Barte

Banco do Brasil

Braintree

Braspag

Cielo

Getnet

Klap

Mercado Pago

PicPay

Pagar.me

Pagar.me v5

PagSeguro

SafraPay

WorldPay

Zoop

Provedores de antifraude

Idempotência

Migração de cartões

Token CVV

Validação de Cartões

Tokenização de Bandeira

Fluxos no Dashboard

Fluxos Inteligentes no Dashboard Malga

Visualização

Visualizando o fluxo

Criando fluxo

Começando um novo fluxo

Condicionais

Utilizando condicionais

Histórico

Histórico de fluxos

Editando Fluxo

Validação e publicação

Exemplos

Exemplos de uso

Erros

Gestão de Cobranças

Usuários e Permissões

Link de Pagamento

Exportando dados

Exportando dados através do Dashboard

Relatório Simples

Relatório simples (pelo último status da cobrança)

Relatório Completo

Relatório completo (com o histórico de operações das cobranças)

Renomear subcontas

v1.1

Webhooks v1.1

v1.0 (obsoleto)

Webhooks v1.0 (obsoleto)

Tabela de códigos MCC

Tabela tipos de moedas aceitas

Tabela tipos de paises e documentos cadastro de Customer

Tabela códigos dos principais bancos

Testando

Testando em Sandbox

Antifraudes Síncronos

Fluxo do Antifraude Síncrono

Antifraudes Assíncronos

Fluxo do Antifraude Assíncrono

Feeding

Fluxo de Feeding

Malga Checkout

Gerenciar Recebedores

Recebedor (seller)

Cobrança com Split

Provedores suportados

Criando sessão

Criando sessão com 3DS2 Malga

Script de coleta de dados

Criando cobrança

Criando uma Cobrança com 3DS2 Malga

Script de desafio

Cobrança com 3DS2

Como funciona o 3D Secure 2

Fluxos com desafio

Recorrência

Sessões

Getting Started

Node.js

Express

SDK JS

Checkout SDK em Javascript

SDK Angular.js

SDK React.js

SDK Vue.js

Checkout Full SDK em Javascript

Magento

WooCommerce

Conector VTEX

Sobre as APIs

Criar nova chave pública para uso no client-side

Listar cartões

Criar novo cartão a partir de token

Recuperar detalhes de cartão

Criar um novo token

Listar cobranças

Realizar nova cobrança

Recuperar detalhes de cobrança

Alterar o status de uma cobrança no ambiente de sandbox

Alterar o status do antifraude no ambiente de sandbox

Capturar cobrança pre-autorizada

Estornar cobrança aprovada

Criar nova sessão

Recuperar detalhes de uma sessão

Atualizar o status de uma sessão

Pagar uma sessão

Cancelar uma sessão

Recuperar o histórico da sessão

Recupera sessão com os dados das configurações da empresa

Listagem de customers cadastrados

Criação de novo customer para cobrança

Recuperar detalhes de customer

Deletar customer pelo id

Atualizar customer pelo id

Listagem dos cartões do customer

Adicionar cartão de crédito ao customer

Listagem de merchants cadastrados

Criação de novo merchant para cobrança

Recuperar detalhes de merchant pelo id

Deletar merchant pelo id

Atualizar configurações de merchant

Listagem de vendedores paginada

Criação de um novo vendedor

Atualizar um vendedor

Recuperar detalhes de um vendedor

Deletar vededor pelo id

Criação de um novo recebedor

Consultar um recebedor pelo ID

Consultar um recebedor por listagem paginada

Deletar recebedor por ID

Atualização de recebedor pelo ID

Recuperar todos os fluxos paginado

Consultar um fluxo pelo id

Listagem de webhooks cadastrados

Criação de novo webhook para notificação

Recuperar detalhes de webhook

Deletar webhook pelo id

Atualizar webhook pelo id

Exportar dados da base

Recuperar detalhes de uma exportação

Os arquivos podem ser baixados durante um período de até 30 dias após a data de exportação. Depois desse período, os arquivos não estarão mais disponíveis para download.

Fazer download de um arquivo

Configurar link de pagamento personalizado

Recuperar configuração de link de pagamento personalizado

Editar configuração de link de pagamento

Dec 18 - Barte

Dez 13 - 3DSecure2 Agnóstico

Dez 10 - Performance | Painel de Dados

Nov 14 - API Settings

Nov 11 - Query Cards | Analytics

Oct 21 - Dados de Bandeira e novidades no Painel

Oct 21 - Bandeira de cartão | Painel

Novos filtros de provedor e método de pagamento

Oct 07 - Novos filtros

Sep 19 - Barte

Sep 10 - Usuários e permissões

Sep 04 - PicPay PIX

Melhorias de UX no Dashboard e novas documentações

Aug 29 - Dashboard

Aug 19 - Picpay

July 05 - Busca de cobranças

July 03 - Facilitadores de pagamentos

Adição do parâmetro splitRules no estorno para possibilitar o estorno parcial de split

June 28 - Estorno Parcial de Split

Serviços	Crédito	Pix	Boleto	Voucher
Cobrança
Pré-autorização
Captura parcial
Estorno parcial
Estorno total
Split
Antifraude próprio
3DS
Token de Bandeira
Validação de cartão (zero dollar auth)
Flag de recorrência
Notificação de abertura de disputa
Notificação de chargedback
Suporte a moedas internacionais

Comece na Malga

Conexões

Guias

Serviços adicionais

Stripe

Funções por métodos de pagamento suportados

Comece na Malga

Conexões

Guias

Serviços adicionais

​Funções por métodos de pagamento suportados

Funções por métodos de pagamento suportados