Backend do Portal do Parceiro API

Modelo de Backend do Portal do Parceiro API
Acesso do Parceiro, Tráfego da API e Documentação

Q: Como é um pipeline saudável para o portal de parceiros API quando o trabalho é sensível e baseado em prazos?

Um backend de portal de parceiros API é um esquema e API de BaaS para contas de parceiros, gerenciamento de chaves API, logs de uso e documentação de desenvolvedores em um espaço de trabalho compartilhado.

Q: Quais fluxos de trabalho do portal de parceiros API se beneficiam mais de tarefas estruturadas em vez de anotações livres?

Inclui User (nome de usuário, email, senha, função), PartnerOrganization (nome, status, contato principal, nível de suporte), APIKey (nomeDaChave, prefixoDoToken, escopos, ativo, ultimaUsadoEm, parceiro, criadoPor), UsageLog (parceiro, apiKey, endpoint, método, códigoDeStatus, contagemDeRequisições, ocorridoEm) e DeveloperDoc (título, slug, conteúdo, versãoApi, estáPublicada, proprietário, parceiro), além de um diagrama ER, playground API e um prompt de Agente AI.

Q: O modelo de acesso é granular o suficiente para parceiros e contratados do portal de parceiros API?

Back4app fornece banco de dados gerenciado, autenticação, consultas em tempo real e esquema flexível para que você possa implementar contas de parceiros, manuseio de APIKey, rastreamento de UsageLog e publicação de docs sem precisar executar seu próprio backend.

Q: Como faço para executar consultas para chaves e logs com Flutter?

Use as classes APIKey e UsageLog para consultar registros de parceiros, classificar por ocorridoEm e exibir o estado da chave e a atividade de uso no portal.

Q: Como gerencio o acesso ao portal de parceiros da API com Next.js Server Actions?

Use uma ação de servidor para criar um Objeto Parse para APIKey com um ponteiro de PartnerOrganization e campos de status, em seguida, valide o acesso no Cloud Code antes de salvar.

Q: O React pode registrar logs de uso do cache offline?

Sim. Ative o Local Datastore e fixe os resultados de UsageLog e APIKey para que os administradores possam inspecionar solicitações recentes e o estado da chave sem conectividade.

Q: Como posso evitar o acesso não autorizado à chave?

No Cloud Code beforeSave para APIKey, exija que o chamador tenha um papel aprovado e rejeite solicitações que tentem alterar tokenPrefix, scopes, isActive ou lastUsedAt sem permissão.

Q: Qual é a melhor maneira de mostrar o uso do parceiro no Android?

Consultando o UsageLog por parceiro e apiKey, em seguida, exibindo endpoint, method, statusCode e requestCount com a paginação do SDK Back4app e cache local quando necessário.

Q: Como funciona o fluxo de rotação da chave da API de ponta a ponta?

Um administrador cria ou rotaciona um APIKey para uma PartnerOrganization, o portal armazena o novo tokenPrefix, scopes e estado isActive, UsageLog começa a registrar solicitações sob essa chave, e a equipe de documentação publica uma atualização correspondente do DeveloperDoc para desenvolvedores parceiros.

Um backend de portal do parceiro API pronto para produção em Back4app com Usuário, PartnerOrganization, APIKey, UsageLog e DeveloperDoc. Inclui diagrama ER, dicionário de dados, esquema JSON, playground de API, e um prompt de Agente de IA para configuração rápida.

Construir com Agente AI Escolha Sua Tecnologia

Principais Pontos do Portal

Este modelo fornece um backend de portal para parceiros com gerenciamento de APIKey, revisão do UsageLog e publicação do DeveloperDoc, para que equipes internas e parceiros externos compartilhem uma superfície de trabalho.

Controle do ciclo de vida da APIKey — Modele registros de APIKey com propriedade do parceiro, tokenPrefix, escopos, isActive e campos lastUsedAt.
Visibilidade do UsageLog — Rastreie entradas do UsageLog por apiKey para que você possa revisar chamadas de endpoint, picos de statusCode e totais de requestCount.
Atualizações do DeveloperDoc — Mantenha os registros do DeveloperDoc alinhados com as orientações da API publicadas, usando título, slug, conteúdo, apiVersion e isPublished.
Limites de acesso do parceiro — Use ACLs e CLPs para manter os espaços de trabalho da PartnerOrganization, as linhas de APIKey e os registros de UsageLog restritos à conta correta.
Backend de portal multiplataforma — Atenda clientes web e móveis através de uma API REST e GraphQL para Usuário, PartnerOrganization, APIKey, UsageLog e DeveloperDoc.

O que é o Modelo de Portal de Parceiros da API?

As permissões são importantes no portal de parceiros da API: parceiros, funcionários e clientes devem ver exatamente o que seu papel exige — nada mais, nada menos. A confiabilidade é um recurso, não uma nota de rodapé. Este modelo modela PartnerOrganization, APIKey, UsageLog e DeveloperDoc com acesso baseado em função na Back4app, para que cada membro da equipe do portal de parceiros da API veja a parte do pipeline que possui. O esquema cobre Usuário (nome de usuário, e-mail, senha, papel), PartnerOrganization (nome, status, contato principal, nível de suporte), APIKey (keyName, tokenPrefix, scopes, isActive, lastUsedAt, partner, createdBy), UsageLog (partner, apiKey, endpoint, method, statusCode, requestCount, occurredAt) e DeveloperDoc (título, slug, conteúdo, apiVersion, isPublished, owner, partner) com suporte a autenticação, regras de visibilidade e fluxo de trabalho do parceiro integrados. Conecte seu frontend preferido e envie mais rápido.

Melhor para:

Portais de parceiros da APIPainéis de ciclo de vida da APIKeyConsoles de análise de UsageLogCentros de publicação de DeveloperDocIntegrações B2BEquipes escolhendo BaaS para acesso compartilhado à API

Visão geral do modelo do Portal do Parceiro API

A maioria dos erros do portal do parceiro API são chatos: um timestamp perdido, uma linha duplicada ou uma contagem que estava certa ontem e errada hoje.

O esquema por trás de PartnerOrganization, APIKey e UsageLog é compartilhado entre hubs e páginas técnicas; mudar de frameworks não deve significar redesenhar registros.

Recursos principais do Portal

Cada cartão de tecnologia neste hub usa o mesmo esquema de backend do portal de parceiros com User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc.

Gerenciamento de conta de parceiro

PartnerOrganization mantém nome, status, contatoPrincipal e nível de suporte em um único registro.

Rastreamento do ciclo de vida da APIKey

APIKey armazena keyName, tokenPrefix, scopes, isActive, lastUsedAt, partner e createdBy.

Revisão do UsageLog

UsageLog captura parceiro, apiKey, endpoint, método, statusCode, requestCount e occurredAt.

Publicação do DeveloperDoc

DeveloperDoc armazena título, slug, conteúdo, apiVersion, isPublished, owner e partner.

Por que construir seu backend de Portal de Parceiros API com Back4app?

Back4app oferece a você primitivos User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc para que sua equipe possa se concentrar na experiência do portal, em vez da infraestrutura de backend.

•Gerenciamento de token e parceiro: APIKey está diretamente ligado a PartnerOrganization, facilitando a auditoria de emissão, rotação e desativação.
•Visibilidade de uso que responde a perguntas reais: UsageLog registra endpoint, método, statusCode e requestCount para que o suporte possa rastrear um problema de integração sem adivinhações.
•Atualizações de Docs sem um gargalo de publicação: DeveloperDoc oferece um local estruturado para anotações de endpoint, orientações versionadas e histórico de alterações voltado para o parceiro.

Construa o portal em torno de APIKey, UsageLog e DeveloperDoc primeiro, para que a integração do parceiro tenha um contrato de backend claro.

Benefícios do Portal

Um backend de portal de parceiros que mantém o trabalho de APIKey, revisão do UsageLog e publicação do DeveloperDoc em um só lugar.

Aceleração do onboarding de parceiros

Comece com as classes PartnerOrganization e APIKey em vez de montar tabelas de tokens e regras de acesso do zero.

As equipes de suporte obtêm contexto utilizável

As linhas do UsageLog mostram endpoint, método, statusCode, requestCount e occurredAt quando um parceiro relata uma solicitação com falha.

Manipulação de chaves mais segura

Armazene tokenPrefix e scopes em vez de expor segredos brutos, e altere isActive quando o estado de uma chave mudar.

Documentação versionada permanece organizada

DeveloperDoc fornece notas de versão, direcionamento de apiVersion e o estado de publicação em uma estrutura estável.

Superfície de API única para cada cliente

Portais da web, ferramentas administrativas móveis e painéis internos podem ler os mesmos dados de User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc.

Fluxo de trabalho de bootstrap de IA

Gere rapidamente esquema, regras de acesso e estrutura do portal com um prompt estruturado.

Pronto para lançar seu portal de parceiros da API?

Deixe o Agente de IA Back4app estruturar o back-end do seu portal de parceiros da API e gerar fluxos de APIKey, UsageLog e DeveloperDoc a partir de um prompt.

Construa com o Agente de IA Experimente o Playground da API

Gratuito para começar — 50 prompts de Agente de IA/mês, sem necessidade de cartão de crédito

Stack Tecnológico do Portal

Tudo incluído neste template de backend do portal de parceiros da API.

Frontend

13+ tecnologias

Backend

Back4app

Banco de dados

MongoDB

Autenticação

Autenticação embutida + sessões

API

REST e GraphQL

Em tempo real

Live Queries

Mapa de Relacionamento com Parceiros

Modelo de relacionamento de entidades para o esquema do backend do portal de parceiros da API.

Diagrama ER

Ver fonte do diagrama

Mermaid

erDiagram
    User ||--o{ PartnerOrganization : "primaryContact"
    User ||--o{ APIKey : "createdBy"
    User ||--o{ DeveloperDoc : "owner"
    PartnerOrganization ||--o{ APIKey : "partner"
    PartnerOrganization ||--o{ UsageLog : "partner"
    PartnerOrganization ||--o{ DeveloperDoc : "partner"
    APIKey ||--o{ UsageLog : "apiKey"

    User {
        String objectId PK
        String username
        String email
        String password
        String role
        Date createdAt
        Date updatedAt
    }

    PartnerOrganization {
        String objectId PK
        String name
        String status
        String primaryContactId FK
        String supportTier
        Date createdAt
        Date updatedAt
    }

    APIKey {
        String objectId PK
        String keyName
        String tokenPrefix
        Array scopes
        Boolean isActive
        Date lastUsedAt
        String partnerId FK
        String createdById FK
        Date createdAt
        Date updatedAt
    }

    UsageLog {
        String objectId PK
        String partnerId FK
        String apiKeyId FK
        String endpoint
        String method
        Number statusCode
        Number requestCount
        Date occurredAt
        Date createdAt
        Date updatedAt
    }

    DeveloperDoc {
        String objectId PK
        String title
        String slug
        String content
        String apiVersion
        Boolean isPublished
        String ownerId FK
        String partnerId FK
        Date createdAt
        Date updatedAt
    }

Fluxo de Integração do Portal

Fluxo típico em tempo de execução para autenticação, consulta de APIKey, revisão de UsageLog e atualizações do DeveloperDoc.

Diagrama ER

Ver fonte do diagrama

Mermaid

sequenceDiagram
  participant User
  participant Portal as API Partner Portal App
  participant Back4app as Back4app Cloud

  User->>Portal: Sign in with portal credentials
  Portal->>Back4app: POST /login
  Back4app-->>Portal: Session token

  User->>Portal: Open APIKeys for a partner workspace
  Portal->>Back4app: GET /classes/APIKey?include=partner,createdBy
  Back4app-->>Portal: Token list with scopes and lastUsedAt

  User->>Portal: Create a new APIKey
  Portal->>Back4app: POST /classes/APIKey
  Back4app-->>Portal: APIKey objectId and tokenPrefix

  User->>Portal: Review UsageLog entries for the token
  Portal->>Back4app: GET /classes/UsageLog?include=partner,apiKey&order=-occurredAt
  Back4app-->>Portal: Usage history and statusCode totals

  opt Publish developer notes
    User->>Portal: Update a DeveloperDoc page
    Portal->>Back4app: PUT /classes/DeveloperDoc/:objectId
    Back4app-->>Portal: Updated markdown and publish state
  end

Dicionário de Campos

Referência completa em nível de campo para cada classe no esquema do portal de parceiros da API.

Campo	Tipo	Descrição	Obrigatório
objectId	String	Auto-generated unique identifier	Automático
username	String	Login name for a portal user
email	String	Primary email address for portal access
password	String	Hashed password (write-only)
role	String	Portal role such as admin, partnerAdmin, or developer
createdAt	Date	Auto-generated creation timestamp	Automático
updatedAt	Date	Auto-generated last-update timestamp	Automático

7 campos em User

Controles de Acesso

Como a estratégia de ACL e CLP assegura parceiros, registros de APIKey, entradas de UsageLog e páginas de DeveloperDoc.

Contas com escopo de parceiro

Cada registro de PartnerOrganization deve ser editável apenas por administradores do portal ou pelo User primaryContact designado.

Segurança e rotação de chave

Armazene APIKey.tokenPrefix e escopos em visualizações públicas, e mantenha materiais de chave bruta fora do navegador.

Limites de leitura do log de uso

Limitar as leituras do UsageLog ao parceiro que possui a APIKey e a funções de suporte que precisam de acesso para solução de problemas.

Esquema JSON

Definição bruta do esquema JSON pronta para copiar para Back4app ou usar como referência de implementação.

JSON

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "role": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "PartnerOrganization",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "status": {
          "type": "String",
          "required": true
        },
        "primaryContact": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "supportTier": {
          "type": "String",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "APIKey",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "keyName": {
          "type": "String",
          "required": true
        },
        "tokenPrefix": {
          "type": "String",
          "required": true
        },
        "scopes": {
          "type": "Array",
          "required": true
        },
        "isActive": {
          "type": "Boolean",
          "required": true
        },
        "lastUsedAt": {
          "type": "Date",
          "required": false
        },
        "partner": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PartnerOrganization"
        },
        "createdBy": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "UsageLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "partner": {
          "type": "Pointer",
          "required": true,
          "targetClass": "PartnerOrganization"
        },
        "apiKey": {
          "type": "Pointer",
          "required": true,
          "targetClass": "APIKey"
        },
        "endpoint": {
          "type": "String",
          "required": true
        },
        "method": {
          "type": "String",
          "required": true
        },
        "statusCode": {
          "type": "Number",
          "required": true
        },
        "requestCount": {
          "type": "Number",
          "required": true
        },
        "occurredAt": {
          "type": "Date",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "DeveloperDoc",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "slug": {
          "type": "String",
          "required": true
        },
        "content": {
          "type": "String",
          "required": true
        },
        "apiVersion": {
          "type": "String",
          "required": true
        },
        "isPublished": {
          "type": "Boolean",
          "required": true
        },
        "owner": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "partner": {
          "type": "Pointer",
          "required": false,
          "targetClass": "PartnerOrganization"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Construir com Agente AI

Use o Agente AI Back4app para gerar um verdadeiro aplicativo de portal de parceiros de API a partir deste modelo, incluindo frontend, backend, autenticação e fluxos de APIKey, UsageLog e DeveloperDoc.

Agente AI Back4app

Pronto para construir

Crie um aplicativo backend para o portal de parceiros API na Back4app com este exato esquema e comportamento.

Esquema:
1. Usuário: nomeDeUsuário (String, obrigatório), e-mail (String, obrigatório), senha (String, obrigatório), função (String, obrigatório); objectId, criadoEm, atualizadoEm (sistema).
2. OrganizaçãoParceira: nome (String, obrigatório), status (String, obrigatório), contatoPrincipal (Ponteiro para Usuário, obrigatório), nívelDeSuporte (String, opcional); objectId, criadoEm, atualizadoEm (sistema).
3. ChaveAPI: nomeChave (String, obrigatório), prefixoToken (String, obrigatório), escopos (Array<String>, obrigatório), estáAtivo (Booleano, obrigatório), últimaUsadoEm (Data, opcional), parceiro (Ponteiro para OrganizaçãoParceira, obrigatório), criadoPor (Ponteiro para Usuário, obrigatório); objectId, criadoEm, atualizadoEm (sistema).
4. LogDeUso: parceiro (Ponteiro para OrganizaçãoParceira, obrigatório), chaveAPI (Ponteiro para ChaveAPI, obrigatório), endpoint (String, obrigatório), método (String, obrigatório), códigoStatus (Número, obrigatório), contagemRequisições (Número, obrigatório), ocorreuEm (Data, obrigatória); objectId, criadoEm, atualizadoEm (sistema).
5. DocDesenvolvedor: título (String, obrigatório), slug (String, obrigatório), conteúdo (String, obrigatório), versãoAPI (String, obrigatório), estáPublicado (Booleano, obrigatório), proprietário (Ponteiro para Usuário, obrigatório), parceiro (Ponteiro para OrganizaçãoParceira, opcional); objectId, criadoEm, atualizadoEm (sistema).

Segurança:
- Apenas administradores do portal ou proprietários designados podem atualizar os dados do parceiro. Apenas papéis aprovados podem criar, girar ou revogar registros de ChaveAPI. Restringir leituras de LogDeUso ao parceiro proprietário e funções de suporte.

Autenticação:
- Cadastro, login, logout.

Comportamento:
- Listar parceiros, criar e girar registros de ChaveAPI, revisar entradas de LogDeUso e publicar páginas de DocDesenvolvedor.

Entrega:
- Aplicativo Back4app com esquema, ACLs, CLPs; frontend para contas de parceiros, gerenciamento de chave API, logs de uso e documentação para desenvolvedores.

Pressione o botão abaixo para abrir o Agente com este prompt de modelo pré-preenchido.

Esta é a solicitação base sem um sufixo de tecnologia. Você pode adaptar a pilha de frontend gerada depois.

Implantar em minutos50 solicitações gratuitas / mêsNenhum cartão de crédito necessário

Playground API

Experimente os endpoints REST e GraphQL contra o esquema do portal de parceiros API. As respostas usam dados fictícios e não requerem uma conta Back4app.

Carregando playground…

Utiliza o mesmo esquema que este template.

Escolha sua Stack

Expanda cada cartão para ver como integrar PartnerOrganization, APIKey e UsageLog com sua pilha escolhida.

O que você recebe com cada tecnologia

Cada pilha usa o mesmo esquema de backend do portal de parceiros da API e contratos da API.

Estrutura de dados do portal unificada

Gerencie registros de Usuário, PartnerOrganization, APIKey, UsageLog e DeveloperDoc com um esquema consistente.

Controles de ciclo de vida da chave da API

Emita, rotacione e revogue registros de APIKey sem perder o histórico de propriedade.

Visibilidade do uso para equipes de suporte

Inspecione entradas do UsageLog por endpoint, método e statusCode quando parceiros precisarem de ajuda.

Rastreamento de lançamento de documentação

Publique atualizações do DeveloperDoc com notas específicas de apiVersion para desenvolvedores parceiros.

APIs REST/GraphQL para clientes do portal

Atenda ferramentas administrativas internas e aplicativos voltados para parceiros por meio de uma camada de API.

Arquitetura extensível para fluxos de trabalho de parceiros

Adicione classes como anúncios ou assinaturas de webhook sem reescrever o núcleo do portal.

Comparação de Pilha de Portal

Compare velocidade de configuração, estilo de SDK e suporte a IA entre todas as tecnologias suportadas.

Framework	Tempo de Configuração	Benefício do Portal	Tipo de SDK	Suporte a IA
Flutter	Cerca de 5 min	Base de código única para portal do parceiro em dispositivos móveis e web.	SDK Digitado	Completo
React	Menos de 5 minutos	Painel web rápido para chaves e logs de parceiros.	SDK Digitado	Completo
React Nativo	~3–7 min	Aplicativo móvel multiplataforma para suporte a parceiros.	SDK Digitado	Completo
Next.js	Configuração rápida (5 min)	Portal de administração renderizado no servidor para chaves e documentos.	SDK Digitado	Completo
JavaScript	~3–5 min	Integração web leve para operações de parceiros.	SDK Digitado	Completo
Android	Sobre 5 min	Aplicativo nativo Android para operações de parceiros.	SDK Digitado	Completo
iOS	Menos de 5 minutos	Aplicativo nativo iOS para operações de parceiros.	SDK Digitado	Completo
Vue	~3–7 min	Interface web Reactive para revisão de chaves e documentos.	SDK Digitado	Completo
Angular	Configuração rápida (5 min)	Portal empresarial para acesso e revisão de uso.	SDK digitado	Completo
GraphQL	Abaixo de 2 min	API flexível GraphQL para portal de parceiros.	API GraphQL	Completo
REST API	Configuração rápida (2 min)	Integração REST API para portal de parceiros.	REST API	Completo
PHP	~3 min	Backend do PHP do lado do servidor para o portal de parceiros.	REST API	Completo
.NET	~3–7 min	Backend do .NET para o portal de parceiros.	SDK Digitado	Completo

O tempo de configuração reflete a duração esperada desde a inicialização do projeto até a primeira consulta de PartnerOrganization, APIKey ou UsageLog usando este esquema de modelo.

Portal de Perguntas

Perguntas comuns sobre como construir um backend de portal de parceiros de API com este modelo.

Como é um pipeline saudável para o portal de parceiros API quando o trabalho é sensível e baseado em prazos?

Quais fluxos de trabalho do portal de parceiros API se beneficiam mais de tarefas estruturadas em vez de anotações livres?

O modelo de acesso é granular o suficiente para parceiros e contratados do portal de parceiros API?

Como faço para executar consultas para chaves e logs com Flutter?

Como gerencio o acesso ao portal de parceiros da API com Next.js Server Actions?

O React pode registrar logs de uso do cache offline?

Como posso evitar o acesso não autorizado à chave?

Qual é a melhor maneira de mostrar o uso do parceiro no Android?

Como funciona o fluxo de rotação da chave da API de ponta a ponta?

Confiado por desenvolvedores em todo o mundo

Junte-se a equipes que enviam produtos de portal de parceiros de API mais rapidamente com os templates do Back4app

Pronto para construir seu aplicativo de portal de parceiros de API?

Comece seu projeto de portal de parceiros em minutos. Nenhum cartão de crédito necessário.

Escolha a Tecnologia

Modelo de Backend do Portal do Parceiro APIAcesso do Parceiro, Tráfego da API e Documentação