Backend del Portal de Socios API

Plantilla del Backend del Portal de Socios API
Acceso de Socios, Tráfico API y Documentación

Q: ¿Cómo se ve un pipeline saludable de portal de API para socios cuando el trabajo es sensible y impulsado por plazos?

Un backend de portal de API para socios es un esquema y API de BaaS para cuentas de socios, gestión de claves API, registros de uso y documentación para desarrolladores en un espacio de trabajo compartido.

Q: ¿Qué flujos de trabajo de portal de API para socios se benefician más de tareas estructuradas en comparación con notas libres?

Incluye User (nombre de usuario, correo electrónico, contraseña, rol), PartnerOrganization (nombre, estado, contacto principal, nivel de soporte), APIKey (nombreClave, prefijoToken, alcances, estáActivo, últimaUtilización, socio, creadoPor), UsageLog (socio, claveAPI, endpoint, método, códigoEstado, conteoSolicitudes, ocurrióEn), y DeveloperDoc (título, slug, contenido, versiónAPI, estáPublicado, propietario, socio), además de un diagrama ER, playground de API y un prompt de Agente AI.

Q: ¿Es el modelo de acceso lo suficientemente granular para los socios y contratistas del portal de API?

Back4app proporciona base de datos gestionada, autenticación, consultas en tiempo real y esquema flexible para que puedas implementar cuentas de socios, manejo de claves API, seguimiento de UsageLog y publicación de docs sin tener que ejecutar tu propio backend.

Q: ¿Cómo ejecuto consultas para claves y registros con Flutter?

Usa las clases APIKey y UsageLog para consultar registros de socios, ordenar por ocurridoEn y mostrar el estado de la clave y la actividad de uso en el portal.

Q: ¿Cómo manejo el acceso al portal de socios de API con Next.js Server Actions?

Utiliza una acción de servidor para crear un objeto Parse para APIKey con un puntero a PartnerOrganization y campos de estado, luego valida el acceso en Cloud Code antes de guardar.

Q: ¿Puede React registrar el uso de caché en modo offline?

Sí. Habilita Local Datastore y fija los resultados de UsageLog y APIKey para que los administradores puedan inspeccionar solicitudes recientes y el estado de la clave sin conectividad.

Q: ¿Cómo evito el acceso no autorizado a la clave?

En Cloud Code beforeSave para APIKey, requiere que el llamador tenga un rol aprobado y rechaza solicitudes que intenten cambiar tokenPrefix, scopes, isActive o lastUsedAt sin permiso.

Q: ¿Cuál es la mejor manera de mostrar el uso del socio en Android?

Consulta UsageLog por socio y apiKey, luego muestra endpoint, método, statusCode y requestCount con paginación del SDK de Back4app y almacenamiento en caché local donde sea necesario.

Q: ¿Cómo funciona el flujo de rotación de la clave de API de extremo a extremo?

Un administrador crea o rota un APIKey para una PartnerOrganization, el portal almacena el nuevo tokenPrefix, scopes y estado isActive, UsageLog comienza a registrar solicitudes bajo esa clave y el equipo de documentación publica una actualización correspondiente de DeveloperDoc para los desarrolladores socios.

Un backend de portal de socios API listo para producción en Back4app con Usuario, PartnerOrganization, APIKey, UsageLog y DeveloperDoc. Incluye diagrama ER, diccionario de datos, esquema JSON, área de pruebas de API y un prompt de AI Agent para una configuración rápida.

Construir con Agente de IA Elige tu tecnología

Conclusiones del portal

Esta plantilla te proporciona un backend de portal de socios de API con gestión de APIKey, revisión de UsageLog y publicación de DeveloperDoc para que los equipos internos y los socios externos compartan una superficie de trabajo.

Control del ciclo de vida de APIKey — Modela los registros de APIKey con campos de propiedad del socio, tokenPrefix, scopes, isActive y lastUsedAt.
Visibilidad de UsageLog — Rastrea las entradas de UsageLog por apiKey para que puedas revisar las llamadas a los puntos finales, picos de statusCode y totales de requestCount.
Actualizaciones de DeveloperDoc — Mantén los registros de DeveloperDoc alineados con las pautas de API publicadas utilizando título, slug, contenido, apiVersion y isPublished.
Límites de acceso de socios — Utiliza ACLs y CLPs para mantener los espacios de trabajo de PartnerOrganization, las filas de APIKey y los registros de UsageLog dentro de la cuenta correcta.
Backend de portal multiplataforma — Sirve a clientes web y móviles a través de una API REST y GraphQL para Usuario, PartnerOrganization, APIKey, UsageLog y DeveloperDoc.

¿Qué es la Plantilla del Portal para Socios de la API?

Los permisos son importantes en el portal para socios de la API: los socios, el personal y los clientes deben ver exactamente lo que su rol requiere — nada más, nada menos. La fiabilidad es una característica, no una aclaración. Esta plantilla modela PartnerOrganization, APIKey, UsageLog y DeveloperDoc con acceso basado en roles en Back4app para que cada miembro del equipo del portal para socios de la API vea la parte del pipeline que le corresponde. El esquema cubre Usuario (nombre de usuario, correo electrónico, contraseña, rol), PartnerOrganization (nombre, estado, contacto principal, nivel de soporte), APIKey (nombreClave, prefijoToken, alcances, estáActivo, últimaUsadoEn, socio, creadoPor), UsageLog (socio, apiKey, endpoint, método, códigoEstado, cantidadSolicitudes, ocurrióEn) y DeveloperDoc (título, slug, contenido, versiónAPI, estáPublicado, propietario, socio) con autenticación, reglas de visibilidad y soporte para flujo de trabajo de socios incorporado. Conecta tu frontend preferido y entrega más rápido.

Mejor para:

Portales para socios de la APIDashboards del ciclo de vida de la clave APIConsolas de análisis de UsageLogCentros de publicación de DeveloperDocIntegraciones B2BEquipos eligiendo BaaS para acceso compartido a la API

Descripción general de la plantilla del Portal de Socios API

La mayoría de los errores en el portal de socios API son aburridos: una marca de tiempo faltante, una fila duplicada o un conteo que era correcto ayer y es incorrecto hoy.

El esquema detrás de PartnerOrganization, APIKey y UsageLog se comparte entre centros y páginas técnicas; cambiar de marcos no debería significar rediseñar records.

Características principales del portal

Cada tarjeta de tecnología en este hub usa el mismo esquema de backend del portal de socios con User, PartnerOrganization, APIKey, UsageLog y DeveloperDoc.

Gestión de cuentas de socios

PartnerOrganization mantiene el nombre, estado, contacto principal y nivel de soporte en un solo registro.

Seguimiento del ciclo de vida de la APIKey

APIKey almacena keyName, tokenPrefix, scopes, isActive, lastUsedAt, partner y createdBy.

Revisión de UsageLog

UsageLog captura socio, apiKey, endpoint, método, statusCode, requestCount y occurredAt.

Publicación de DeveloperDoc

DeveloperDoc almacena título, slug, contenido, apiVersion, isPublished, propietario y socio.

¿Por qué construir el backend de su portal de socios API con Back4app?

Back4app le proporciona User, PartnerOrganization, APIKey, UsageLog y DeveloperDoc primitivos para que su equipo pueda centrarse en la experiencia del portal en lugar de la plomería del backend.

•Gestión de tokens y socios: APIKey se vincula directamente a PartnerOrganization, facilitando la auditoría de emisión, rotación y desactivación.
•Visibilidad de uso que responde a preguntas reales: UsageLog registra endpoint, método, statusCode y requestCount para que el soporte pueda rastrear un problema de integración sin conjeturas.
•Actualizaciones de documentos sin un cuello de botella de publicación: DeveloperDoc le proporciona un lugar estructurado para notas de endpoint, guía versionada e historial de cambios para socios.

Construya el portal alrededor de APIKey, UsageLog y DeveloperDoc primero para que la incorporación de socios tenga un contrato backend claro.

Beneficios del Portal

Un backend del portal de socios que mantiene el trabajo de APIKey, la revisión de UsageLog y la publicación de DeveloperDoc en un solo lugar.

Onboarding de socios más rápido

Comience con las clases PartnerOrganization y APIKey en lugar de ensamblar tablas de tokens y reglas de acceso desde cero.

Los equipos de soporte obtienen contexto útil

Las filas de UsageLog muestran endpoint, método, statusCode, requestCount y occurredAt cuando un socio reporta una solicitud fallida.

Manejo de claves más seguro

Almacene tokenPrefix y scopes en lugar de exponer secretos en bruto, y cambie isActive cuando el estado de una clave cambie.

Documentos versionados se mantienen organizados

DeveloperDoc proporciona notas de versión, targeting de apiVersion y estado de publicación en una estructura estable.

Superficie API única para cada cliente

Portales web, herramientas administrativas móviles y paneles internos pueden leer los mismos datos de User, PartnerOrganization, APIKey, UsageLog y DeveloperDoc.

Flujo de trabajo de arranque de IA

Genera esquemas, reglas de acceso y estructura de portal rápidamente con un solo aviso estructurado.

¿Listo para lanzar tu portal de partner API?

Deja que el Agente de IA de Back4app estructure el backend de tu portal de partner API y genere flujos de APIKey, UsageLog y DeveloperDoc desde un solo aviso.

Construye con el Agente de IA Prueba el API Playground

Gratis para comenzar — 50 avisos de Agente de IA/mes, no se requiere tarjeta de crédito

Stack tecnológico del portal

Todo incluido en esta plantilla de backend del portal de socios de API.

Frontend

13+ tecnologías

Backend

Back4app

Base de datos

MongoDB

Autenticación

Autenticación integrada + sesiones

API

REST y GraphQL

Tiempo real

Live Queries

Mapa de Relaciones con Socios

Modelo de relación de entidades para el esquema de backend del portal de socios API.

Diagrama ER

Ver fuente del 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
    }

Flujo de Integración del Portal

Flujo de ejecución típico para inicio de sesión, búsqueda de APIKey, revisión de UsageLog y actualizaciones de DeveloperDoc.

Diagrama ER

Ver fuente del 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

Diccionario de Campos

Referencia completa a nivel de campo para cada clase en el esquema del portal de socios API.

Campo	Tipo	Descripción	Requerido
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 campos en User

Controles de acceso

Cómo la estrategia ACL y CLP asegura socios, registros de APIKey, entradas de UsageLog y páginas de DeveloperDoc.

Cuentas con ámbito de socio

Cada registro de PartnerOrganization solo debe ser editable por administradores del portal o por el usuario asignado como contacto principal.

Secreto de clave y rotación

Almacene APIKey.tokenPrefix y scopes en vistas públicas, y mantenga el material de clave sin procesar fuera del navegador.

Límites de lectura del registro de uso

Limitar las lecturas de UsageLog al socio que posee la APIKey y a los roles de soporte que necesitan acceso de solución de problemas.

Esquema JSON

Definición de esquema JSON en bruto lista para copiar en Back4app o usar como referencia de implementación.

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 con el Agente de IA

Usa el Agente de IA de Back4app para generar una aplicación real del portal de socios API a partir de esta plantilla, incluidos frontend, backend, autenticación, y flujos de APIKey, UsageLog y DeveloperDoc.

Agente de IA de Back4app

Listo para construir

Crea un backend de aplicación de portal para socios de API en Back4app con este esquema y comportamiento exactos.

Esquema:
1. Usuario: nombre de usuario (String, requerido), correo electrónico (String, requerido), contraseña (String, requerido), rol (String, requerido); objectId, createdAt, updatedAt (sistema).
2. OrganizaciónSocio: nombre (String, requerido), estado (String, requerido), contactoPrincipal (Puntero a Usuario, requerido), nivelDeSoporte (String, opcional); objectId, createdAt, updatedAt (sistema).
3. ClaveAPI: nombreClave (String, requerido), prefijoToken (String, requerido), alcances (Array<String>, requerido), estaActivo (Boolean, requerido), ultimaUso (Date, opcional), socio (Puntero a OrganizaciónSocio, requerido), creadoPor (Puntero a Usuario, requerido); objectId, createdAt, updatedAt (sistema).
4. RegistroUso: socio (Puntero a OrganizaciónSocio, requerido), claveAPI (Puntero a ClaveAPI, requerido), puntoFinal (String, requerido), método (String, requerido), codigoEstado (Number, requerido), contadorSolicitudes (Number, requerido), ocurrioEn (Date, requerido); objectId, createdAt, updatedAt (sistema).
5. DocDesarrollador: título (String, requerido), slug (String, requerido), contenido (String, requerido), versionAPI (String, requerido), estaPublicada (Boolean, requerido), propietario (Puntero a Usuario, requerido), socio (Puntero a OrganizaciónSocio, opcional); objectId, createdAt, updatedAt (sistema).

Seguridad:
- Solo los administradores del portal o propietarios asignados pueden actualizar los datos de los socios. Solo los roles aprobados pueden crear, rotar o revocar registros de ClaveAPI. Restringir las lecturas de RegistroUso al socio propietario y roles de soporte.

Autenticación:
- Registro, inicio de sesión, cierre de sesión.

Comportamiento:
- Listar socios, crear y rotar registros de ClaveAPI, revisar entradas de RegistroUso y publicar páginas de DocDesarrollador.

Entregar:
- Aplicación Back4app con esquema, ACLs, CLPs; frontend para cuentas de socios, gestión de clave API, registros de uso y documentación para desarrolladores.

Presiona el botón de abajo para abrir el Agente con este aviso de plantilla prellenado.

Este es el aviso base sin un sufijo de tecnología. Puedes adaptar la pila de frontend generada después.

Desplegar en minutos50 avisos gratuitos / mesNo se requiere tarjeta de crédito

API Playground

Prueba los endpoints REST y GraphQL contra el esquema del portal para socios de API. Las respuestas utilizan datos de prueba y no requieren una cuenta de Back4app.

Cargando el área de juegos…

Utiliza el mismo esquema que esta plantilla.

Elige tu stack

Expande cada tarjeta para ver cómo integrar PartnerOrganization, APIKey y UsageLog con tu pila elegida.

Lo que obtienes con cada tecnología

Cada pila utiliza el mismo esquema de backend del portal de socios API y contratos de API.

Estructura de datos del portal unificado

Gestiona registros de Usuario, PartnerOrganization, APIKey, UsageLog y DeveloperDoc con un esquema consistente.

Controles del ciclo de vida de la clave API

Emite, rota y revoca registros de APIKey sin perder la trazabilidad de propiedad.

Visibilidad de uso para equipos de soporte

Inspeccionar entradas de UsageLog por punto final, método y statusCode cuando los socios necesitan ayuda.

Seguimiento de la publicación de la documentación

Publicar actualizaciones de DeveloperDoc con notas específicas de la apiVersion para desarrolladores socios.

APIs REST/GraphQL para clientes del portal

Servir herramientas de administración internas y aplicaciones orientadas a socios a través de una capa de API.

Arquitectura extensible para flujos de trabajo de socios

Agregar clases como anuncios o suscripciones a webhooks sin reescribir el núcleo del portal.

Comparación de Pilas del Portal

Compara la velocidad de configuración, estilo de SDK y soporte de IA entre todas las tecnologías soportadas.

Marco	Tiempo de configuración	Beneficio del portal	Tipo de SDK	Soporte de IA
Flutter	Acerca de 5 min	Código base único para el portal de socios en móvil y web.	SDK tipeado	Completo
React	Menos de 5 minutos	Panel web rápido para claves y registros de socios.	SDK Escrito	Completo
React Nativo	~3–7 min	Aplicación móvil multiplataforma para soporte de socios.	SDK Escrito	Completo
Next.js	Configuración rápida (5 min)	Portal de administración renderizado en servidor para claves y documentos.	SDK Escrito	Completo
JavaScript	~3–5 min	Integración web ligera para operaciones de socios.	SDK Escrito	Completo
Android	Acerca de 5 min	Aplicación nativa de Android para operaciones de socios.	SDK tipado	Completo
iOS	Menos de 5 minutos	Aplicación nativa de iOS para operaciones de socios.	SDK tipado	Completo
Vue	~3–7 min	Interfaz web Reactiva para revisión clave y documentos.	SDK tipado	Completo
Angular	Configuración rápida (5 min)	Portal empresarial para revisión de acceso y uso.	SDK escrito	Completo
GraphQL	Menos de 2 min	API flexible de GraphQL para el portal de socios.	API de GraphQL	Completo
REST API	Configuración rápida (2 min)	Integración de REST API para el portal de socios.	REST API	Completo
PHP	~3 min	Backend PHP del lado del servidor para el portal de socios.	REST API	Completo
.NET	~3–7 min	Backend .NET para el portal de socios.	SDK tipado	Completo

El tiempo de configuración refleja la duración esperada desde el inicio del proyecto hasta la primera consulta de PartnerOrganization, APIKey o UsageLog utilizando este esquema de plantilla.

Preguntas del portal

Preguntas comunes sobre cómo construir un backend de portal de partner API con esta plantilla.

¿Cómo se ve un pipeline saludable de portal de API para socios cuando el trabajo es sensible y impulsado por plazos?

¿Qué flujos de trabajo de portal de API para socios se benefician más de tareas estructuradas en comparación con notas libres?

¿Es el modelo de acceso lo suficientemente granular para los socios y contratistas del portal de API?

¿Cómo ejecuto consultas para claves y registros con Flutter?

¿Cómo manejo el acceso al portal de socios de API con Next.js Server Actions?

¿Puede React registrar el uso de caché en modo offline?

¿Cómo evito el acceso no autorizado a la clave?

¿Cuál es la mejor manera de mostrar el uso del socio en Android?

¿Cómo funciona el flujo de rotación de la clave de API de extremo a extremo?

Confiado por desarrolladores en todo el mundo

Únete a equipos que lanzan productos de API para el portal de socios más rápido con plantillas de Back4app

¿Listo para construir tu aplicación del portal de socios de API?

Inicia tu proyecto de portal de socios en minutos. No se requiere tarjeta de crédito.

Elige tecnología

Plantilla del Backend del Portal de Socios APIAcceso de Socios, Tráfico API y Documentación