Backend del Portale API Partner

Modello del Backend del Portale API Partner
Accesso Partner, Traffico API e Documentazione

Q: Come appare un pipeline sana di portali per partner API quando il lavoro è sensibile e guidato da scadenze?

Un backend di portale per partner API è uno schema e API per account partner, gestione delle chiavi API, log di utilizzo e documentazione per sviluppatori in uno spazio di lavoro condiviso.

Q: Quali flussi di lavoro del portale per partner API traggono maggior beneficio da attività strutturate rispetto a note libere?

Include User (username, email, password, role), PartnerOrganization (name, status, primaryContact, supportTier), APIKey (keyName, tokenPrefix, scopes, isActive, lastUsedAt, partner, createdBy), UsageLog (partner, apiKey, endpoint, method, statusCode, requestCount, occurredAt) e DeveloperDoc (title, slug, content, apiVersion, isPublished, owner, partner), oltre a un diagramma ER, API playground e un prompt AI Agent.

Q: Il modello di accesso è abbastanza dettagliato per i partner e i collaboratori del portale per partner API?

Back4app fornisce database gestito, autenticazione, query in tempo reale e schema flessibile, così puoi gestire account partner, gestione delle chiavi API, tracciamento dei log di utilizzo e pubblicazione di documenti senza gestire il tuo backend.

Q: Come eseguo query per chiavi e log con Flutter?

Utilizza le classi APIKey e UsageLog per interrogare i record dei partner, ordinare per occurredAt e visualizzare lo stato delle chiavi e l'attività di utilizzo nel portale.

Q: Come posso gestire l'accesso al portale partner API con Next.js Server Actions?

Utilizza un'azione del server per creare un oggetto Parse per APIKey con un puntatore a PartnerOrganization e campi di stato, quindi valida l'accesso nel Cloud Code prima di salvare.

Q: Può React registrare i log dell'utilizzo della cache nativa offline?

Sì. Abilita Local Datastore e blocca i risultati di UsageLog e APIKey in modo che gli amministratori possano ispezionare le richieste recenti e lo stato della chiave senza connettività.

Q: Come posso prevenire l'accesso non autorizzato alla chiave?

Nel Cloud Code beforeSave per APIKey, richiedi al chiamante di avere un ruolo approvato e rifiuta le richieste che tentano di cambiare tokenPrefix, scopes, isActive o lastUsedAt senza autorizzazione.

Q: Qual è il modo migliore per mostrare l'utilizzo dei partner su Android?

Interroga UsageLog per partner e apiKey, quindi visualizza endpoint, method, statusCode e requestCount con la paginazione SDK di Back4app e caching locale dove necessario.

Q: Come funziona il flusso di rotazione della chiave API end-to-end?

Un amministratore crea o ruota un APIKey per una PartnerOrganization, il portale memorizza il nuovo tokenPrefix, scopes e lo stato isActive, UsageLog inizia a registrare le richieste sotto quella chiave, e il team della documentazione pubblica un aggiornamento DeveloperDoc corrispondente per gli sviluppatori partner.

Un backend del portale API partner pronto per la produzione su Back4app con Utente, PartnerOrganization, APIKey, UsageLog e DeveloperDoc. Include diagramma ER, dizionario dei dati, schema JSON, playground API e un prompt AI Agent per una rapida configurazione.

Costruisci con AI Agent Scegli la tua tecnologia

Riepiloghi del portale

Questo modello ti offre un backend per il portale dei partner API con gestione APIKey, revisione dei registri di utilizzo e pubblicazione della documentazione per sviluppatori, affinché i team interni e i partner esterni condividano un unico ambiente di lavoro.

Controllo del ciclo di vita di APIKey — Modella i record di APIKey con proprietà del partner, tokenPrefix, scope, isActive e campi lastUsedAt.
Visibilità dei registri di utilizzo — Monitora le voci dei registri di utilizzo per ogni apiKey in modo da poter rivedere le chiamate agli endpoint, i picchi di statusCode e i totali di requestCount.
Aggiornamenti della documentazione per sviluppatori — Mantieni i record della documentazione per sviluppatori allineati con le linee guida API pubblicate utilizzando titolo, slug, contenuto, apiVersion e isPublished.
Limiti di accesso per i partner — Utilizza ACL e CLP per mantenere gli spazi di lavoro di PartnerOrganization, le righe di APIKey e i registri di UsageLog limitati al giusto account.
Backend del portale multipiattaforma — Serve clienti web e mobile attraverso un'unica API REST e GraphQL per User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc.

Cos'è il Template del Portale Partner API?

I permessi sono importanti nel portale partner API: i partner, il personale e i clienti dovrebbero vedere esattamente ciò che il loro ruolo richiede — niente di più, niente di meno. L'affidabilità è una caratteristica, non una nota a piè di pagina. Questo template modella PartnerOrganization, APIKey, UsageLog e DeveloperDoc con accesso basato sui ruoli su Back4app così ogni membro del portale partner API vede la porzione di pipeline di cui è responsabile. Lo schema copre User (username, email, password, role), PartnerOrganization (name, status, primaryContact, supportTier), APIKey (keyName, tokenPrefix, scopes, isActive, lastUsedAt, partner, createdBy), UsageLog (partner, apiKey, endpoint, method, statusCode, requestCount, occurredAt) e DeveloperDoc (title, slug, content, apiVersion, isPublished, owner, partner) con autenticazione, regole di visibilità e supporto ai workflow dei partner integrati. Collega il tuo frontend preferito e spedisci più velocemente.

Ideale per:

Portali partner APIPanelli di controllo del ciclo di vita delle APIKeyConsole di analisi dei log di utilizzoCentri di pubblicazione della DeveloperDocIntegrazioni B2BTeam che scelgono BaaS per l'accesso API condiviso

Panoramica del modello del Portale API Partner

La maggior parte degli errori nei portali API partner sono noiosi: un timestamp mancante, una riga duplicata o un conteggio che era giusto ieri e sbagliato oggi.

Lo schema dietro PartnerOrganization, APIKey e UsageLog è condiviso tra centri e pagine tecniche; cambiare framework non dovrebbe significare riprogettare record.

Funzionalità principali del portale

Ogni scheda tecnologica in questo hub utilizza lo stesso schema di backend del partner portal con User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc.

Gestione degli account partner

PartnerOrganization mantiene nome, stato, contattoPrincipale e livelloDiSupporto in un unico record.

Tracciamento del ciclo di vita della chiave API

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

Revisione del UsageLog

Il UsageLog cattura partner, apiKey, endpoint, metodo, statusCode, requestCount e occurredAt.

Pubblicazione del DeveloperDoc

Il DeveloperDoc memorizza titolo, slug, contenuto, apiVersion, isPublished, owner e partner.

Perché costruire il backend del tuo portale API Partner con Back4app?

Back4app ti offre primitive User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc affinché il tuo team possa concentrarsi sull'esperienza del portale invece che sulla parte backend.

•Gestione token e partner: APIKey è direttamente collegato a PartnerOrganization, rendendo più semplice l'emissione, la rotazione e la disattivazione per un'accurata revisione.
•Visibilità dell'uso che risponde a domande reali: UsageLog registra endpoint, metodo, statusCode e requestCount affinché il supporto possa seguire un problema di integrazione senza dover indovinare.
•Aggiornamenti dei documenti senza un collo di bottiglia di pubblicazione: DeveloperDoc ti offre un luogo strutturato per appunti sugli endpoint, linee guida versionate e cronologia delle modifiche per il partner.

Costruisci il portale attorno a APIKey, UsageLog e DeveloperDoc prima di tutto, così l'onboarding del partner avrà un contratto backend chiaro.

Vantaggi del Portal

Un backend del partner portal che tiene il lavoro dell'APIKey, la revisione del UsageLog e la pubblicazione del DeveloperDoc in un unico posto.

Acquisizione di partner più rapida

Inizia con le classi PartnerOrganization e APIKey invece di assemblare tabelle di token e regole di accesso da zero.

I team di supporto ottengono contesto utilizzabile

Le righe di UsageLog mostrano endpoint, method, statusCode, requestCount e occurredAt quando un partner riporta una richiesta fallita.

Gestione delle chiavi più sicura

Memorizza tokenPrefix e scopes invece di esporre segreti non elaborati, e ruota isActive quando lo stato di una chiave cambia.

Documenti versionati rimangono organizzati

DeveloperDoc fornisce note di rilascio, targeting dell'apiVersion e uno stato di pubblicazione con una struttura stabile.

Superficie API unica per ogni client

I portali web, gli strumenti di amministrazione mobile e i dashboard interni possono leggere gli stessi dati di User, PartnerOrganization, APIKey, UsageLog e DeveloperDoc.

Flusso di lavoro di avvio AI

Genera rapidamente schema, regole di accesso e impalcatura del portale con un prompt strutturato.

Pronto per lanciare il tuo portale per partner API?

Lascia che l'Agente AI di Back4app impalcatura il backend del tuo portale per partner API e generi flussi APIKey, UsageLog e DeveloperDoc da un solo prompt.

Costruisci con l'Agente AI Prova il Playground API

Gratuito per iniziare — 50 prompt dell'Agente AI/mese, senza carta di credito necessaria

Tech Stack del Portale

Tutto incluso in questo modello di backend del portale partner API.

Frontend

13+ tecnologie

Backend

Back4app

Database

MongoDB

Auth

Autenticazione e sessioni integrate

API

REST e GraphQL

In tempo reale

Live Queries

Mappa delle relazioni con i partner

Modello di relazione delle entità per lo schema backend del portale partner API.

Diagramma ER

Visualizza fonte del diagramma

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
    }

Flusso di integrazione del portale

Flusso di esecuzione tipico per l'accesso, ricerca APIKey, revisione UsageLog e aggiornamenti DeveloperDoc.

Diagramma ER

Visualizza fonte del diagramma

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

Dizionario dei campi

Riferimento completo a livello di campo per ogni classe nello schema del portale partner API.

Campo	Tipo	Descrizione	Obbligatorio
objectId	String	Auto-generated unique identifier	Auto
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	Auto
updatedAt	Date	Auto-generated last-update timestamp	Auto

7 campi in User

Controlli di accesso

Come la strategia ACL e CLP protegge i partner, i record APIKey, le voci UsageLog e le pagine DeveloperDoc.

Account con ambito partner

Ogni record PartnerOrganization dovrebbe essere modificabile solo dagli amministratori del portale o dall'utente primaryContact assegnato.

Segretezza e rotazione delle chiavi

Conservare APIKey.tokenPrefix e gli ambiti in viste pubbliche e mantenere il materiale chiave grezzo fuori dal browser.

Limiti di lettura del registro utilizzo

Limita le letture del UsageLog al partner che possiede l'APIKey e ai ruoli di supporto che necessitano di accesso per la risoluzione dei problemi.

JSON Schema

Definizione dello schema JSON grezzo pronta per essere copiata in Back4app o utilizzata come riferimento per l'implementazione.

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
        }
      }
    }
  ]
}

Costruisci con AI Agent

Utilizza l'AI Agent di Back4app per generare un'app reale di portale partner API da questo modello, inclusi frontend, backend, autenticazione e flussi di APIKey, UsageLog e DeveloperDoc.

Back4app AI Agent

Pronto per costruire

Crea un'app backend del portale partner API su Back4app con questo schema e comportamento esatti.

Schema:
1. Utente: username (Stringa, obbligatoria), email (Stringa, obbligatoria), password (Stringa, obbligatoria), ruolo (Stringa, obbligatoria); objectId, createdAt, updatedAt (sistema).
2. OrganizzazionePartner: nome (Stringa, obbligatoria), stato (Stringa, obbligatoria), contattoPrimario (Puntatore a Utente, obbligatoria), livelloSupporto (Stringa, opzionale); objectId, createdAt, updatedAt (sistema).
3. APIKey: chiaveNome (Stringa, obbligatoria), prefissoToken (Stringa, obbligatoria), ambiti (Array<String>, obbligatori), èAttiva (Booleano, obbligatorio), ultimoUtilizzato (Data, opzionale), partner (Puntatore a OrganizzazionePartner, obbligatorio), creatoDa (Puntatore a Utente, obbligatorio); objectId, createdAt, updatedAt (sistema).
4. RegistroUtilizzo: partner (Puntatore a OrganizzazionePartner, obbligatorio), apiKey (Puntatore a APIKey, obbligatorio), endpoint (Stringa, obbligatoria), metodo (Stringa, obbligatoria), codiceStato (Numero, obbligatorio), conteggioRichieste (Numero, obbligatorio), avvenutoIl (Data, obbligatoria); objectId, createdAt, updatedAt (sistema).
5. DocumentazioneSviluppatore: titolo (Stringa, obbligatoria), slug (Stringa, obbligatoria), contenuto (Stringa, obbligatoria), versioneAPI (Stringa, obbligatoria), èPubblicata (Booleano, obbligatorio), proprietario (Puntatore a Utente, obbligatorio), partner (Puntatore a OrganizzazionePartner, opzionale); objectId, createdAt, updatedAt (sistema).

Sicurezza:
- Solo gli amministratori del portale o i proprietari assegnati possono aggiornare i dati dei partner. Solo i ruoli approvati possono creare, ruotare o revocare i record APIKey. Limita le letture del RegistroUtilizzo al partner proprietario e ai ruoli di supporto.

Autenticazione:
- Registrazione, accesso, disconessione.

Comportamento:
- Elenca i partner, crea e ruota i record APIKey, rivedi le voci del RegistroUtilizzo e pubblica le pagine della DocumentazioneSviluppatore.

Consegna:
- App Back4app con schema, ACL, CLP; frontend per account partner, gestione chiave API, registri di utilizzo e documentazione per sviluppatori.

Premi il pulsante qui sotto per aprire l'Agent con questo prompt precompilato.

Questo è il prompt base senza un suffisso tecnologico. Puoi adattare successivamente lo stack frontend generato.

Distribuisci in pochi minuti50 prompt gratuiti / meseNessuna carta di credito richiesta

API Playground

Prova i REST e gli endpoint GraphQL contro lo schema del portale partner API. Le risposte utilizzano dati fittizi e non richiedono un account Back4app.

Caricamento del playground…

Usa lo stesso schema di questo modello.

Scegli il tuo stack

Espandi ciascuna scheda per vedere come integrare PartnerOrganization, APIKey e UsageLog con il tuo stack scelto.

Cosa ottieni con ogni tecnologia

Ogni stack utilizza lo stesso schema di backend del portale partner API e contratti API.

Struttura dati del portale unificato

Gestisci record di Utente, PartnerOrganization, APIKey, UsageLog e DeveloperDoc con uno schema coerente.

Controlli del ciclo di vita della chiave API

Emetti, ruota e revoca i record APIKey senza perdere la tracciabilità della proprietà.

Visibilità dell'uso per i team di supporto

Ispeziona le voci di UsageLog per endpoint, metodo e statusCode quando i partner hanno bisogno di aiuto.

Tracciamento delle versioni della documentazione

Pubblica aggiornamenti di DeveloperDoc con note specifiche per la versione apiVersion per gli sviluppatori partner.

API REST/GraphQL per clienti del portale

Serve strumenti di amministrazione interni e app per i partner tramite un unico strato API.

Architettura estensibile per i flussi di lavoro dei partner

Aggiungi classi come annunci o abbonamenti a webhook senza riscrivere il core del portale.

Confronto del Stack del Portale

Confronta la velocità di configurazione, lo stile dell'SDK e il supporto per l'IA tra tutte le tecnologie supportate.

Framework	Tempo di configurazione	Vantaggio del portale	Tipo di SDK	Supporto AI
Flutter	Circa 5 minuti	Codice sorgente unico per il portale partner su mobile e web.	SDK tipizzato	Completo
React	Meno di 5 minuti	Dashboard web veloce per chiavi e log dei partner.	SDK digitato	Completo
React Nativo	~3–7 min	App mobile cross-platform per supporto partner.	SDK digitato	Completo
Next.js	Impostazione rapida (5 min)	Portale admin renderizzato dal server per chiavi e documenti.	SDK digitato	Completo
JavaScript	~3–5 min	Integrazione web leggera per le operazioni partner.	SDK digitato	Completo
Android	Circa 5 min	App nativa Android per operazioni partner.	SDK tipizzato	Completo
iOS	Meno di 5 minuti	App nativa iOS per operazioni partner.	SDK tipizzato	Completo
Vue	~3–7 min	Interfaccia web Reactive per la revisione chiave e la documentazione.	SDK tipizzato	Completo
Angular	Impostazione rapida (5 min)	Portale enterprise per accesso e revisione dell'utilizzo.	SDK digitato	Completo
GraphQL	Meno di 2 min	API flessibile GraphQL per il portale partner.	API GraphQL	Completo
REST API	Impostazione veloce (2 min)	Integrazione REST API per il portale partner.	REST API	Completo
PHP	~3 min	Backend PHP lato server per il portale dei partner.	REST API	Completo
.NET	~3–7 min	Backend .NET per il portale dei partner.	SDK tipizzato	Completo

Il tempo di configurazione riflette la durata prevista dalla creazione del progetto alla prima query di PartnerOrganization, APIKey o UsageLog utilizzando questo schema di template.

Domande del Portale

Domande comuni su come costruire un backend per il portale partner API con questo template.

Come appare un pipeline sana di portali per partner API quando il lavoro è sensibile e guidato da scadenze?

Quali flussi di lavoro del portale per partner API traggono maggior beneficio da attività strutturate rispetto a note libere?

Il modello di accesso è abbastanza dettagliato per i partner e i collaboratori del portale per partner API?

Come eseguo query per chiavi e log con Flutter?

Come posso gestire l'accesso al portale partner API con Next.js Server Actions?

Può React registrare i log dell'utilizzo della cache nativa offline?

Come posso prevenire l'accesso non autorizzato alla chiave?

Qual è il modo migliore per mostrare l'utilizzo dei partner su Android?

Come funziona il flusso di rotazione della chiave API end-to-end?

Affidato agli sviluppatori in tutto il mondo

Unisciti ai team che lanciano prodotti per il portale API dei partner più velocemente con i template di Back4app

Pronto a costruire la tua app per il portale API dei partner?

Inizia il tuo progetto di portale per i partner in pochi minuti. Nessuna carta di credito necessaria.

Scegli tecnologia

Modello del Backend del Portale API PartnerAccesso Partner, Traffico API e Documentazione