Authentification

Clés API, scopes, liste d’IP autorisées, rotation et OAuth 2.1 pour les agents.

STRIKE accepte deux types d'identifiants, toujours envoyés dans l'en-tête Authorization: Bearer : les clés API, pour vos serveurs et scripts, et les jetons OAuth 2.1, délivrés aux agents IA après votre consentement.

L'en-tête Authorization

HTTP
GET /api/platform/v1/me HTTP/1.1
Host: strikespace.net
Authorization: Bearer sk_live_votre_cle
Accept: application/json
Préfixe Type Usage
sk_live_ Clé API secrète Vos serveurs, scripts, outils d'automatisation, CI. Créée dans le dashboard.
stk_at_ Jeton d'accès OAuth Agents IA connectés (Claude, ChatGPT…). Valable 1 heure.
stk_rt_ Jeton de renouvellement OAuth Échangé contre un nouveau jeton d'accès. Valable 30 jours, à usage unique.
strk_ Clé de tracking publique Uniquement l'API de tracking v1 (en-tête X-Strike-Key). Ne donne accès à aucune donnée.

Clés API

Les clés se gèrent dans Développeurs → Clés API. Seuls le propriétaire du compte et les administrateurs de l'équipe peuvent en créer ou en révoquer ; une clé agit avec les droits d'un administrateur, dans la limite de ses scopes.

  • Format : sk_live_ suivi de 32 caractères aléatoires (≈ 190 bits d'entropie). Le dashboard n'affiche ensuite que le début et les 4 derniers caractères (sk_live_AbCd…wxyz).
  • Affichée une seule fois : STRIKE ne conserve qu'une empreinte HMAC-SHA256 de la clé. Une clé perdue ne peut pas être récupérée : créez-en une nouvelle.
  • Expiration facultative : passé cette date, la clé est refusée (401).
  • Liste d'IP autorisées facultative : adresses exactes (IPv4 ou IPv6) ou plages IPv4 en notation CIDR (203.0.113.0/24). Un appel depuis une autre adresse reçoit 403 avec code: "ip_not_allowed".
  • Suivi : la date et l'adresse IP de dernière utilisation s'affichent à côté de chaque clé ; le détail des appels est dans Développeurs → Journal (30 jours).
  • Nombre de clés actives : 10 en Pro, 50 en Enterprise.

Rotation d'une clé

Pour remplacer une clé sans interruption de service :

  1. Créez une nouvelle clé avec les mêmes scopes.
  2. Déployez-la dans votre gestionnaire de secrets et redémarrez vos services.
  3. Vérifiez dans le dashboard que l'ancienne clé n'est plus utilisée (date de dernière utilisation).
  4. Révoquez l'ancienne clé. La révocation est immédiate et définitive.

Nous recommandons une rotation au moins tous les 90 jours, et immédiatement si une clé a pu être exposée (dépôt Git, capture d'écran, départ d'un prestataire).

Scopes

Chaque clé et chaque agent ne peut faire que ce que ses scopes autorisent. Un appel hors scope reçoit 403 avec code: "insufficient_scope". Les actions d'écriture et d'envoi ont leur propre scope : une intégration en lecture seule ne peut jamais rien modifier.

Scope Autorise
leads:read Lire les leads
leads:write Créer, modifier et supprimer des leads
events:read Lire les événements de tracking
events:write Envoyer des événements de tracking
segments:read Lire les segments et leurs membres
funnels:read Lire les tunnels et leurs statistiques
campaigns:read Lire les flux de relance
campaigns:write sensible Inscrire des leads dans un flux (envoi de messages)
journeys:read Lire les parcours
journeys:write Inscrire des leads dans un parcours
social:read Lire les marques, publications et stratégies
social:write Créer et modifier des publications (brouillons, validation)
social:publish sensible Planifier et publier sur les réseaux sociaux
payments:read Lire les paiements des tunnels
webhooks:manage sensible Gérer les webhooks

Les scopes sensibles (campaigns:write, social:publish, webhooks:manage) envoient des messages, publient ou reconfigurent votre compte : ils ne sont jamais cochés par défaut. Sans social:publish, une publication créée par l'API reste un brouillon ou part en validation auprès de votre équipe.

OAuth 2.1 pour les agents IA

Les clients MCP (Claude, ChatGPT, Cursor, VS Code…) se connectent sans clé : ils s'enregistrent automatiquement, vous redirigent vers une page de consentement STRIKE, puis reçoivent des jetons de courte durée. Si vous utilisez un client du marché, tout est automatique : cette section intéresse ceux qui développent leur propre client.

Métadonnées du serveur d'autorisation (RFC 8414) https://strikespace.net/.well-known/oauth-authorization-server
Métadonnées de ressource protégée (RFC 9728) https://strikespace.net/.well-known/oauth-protected-resource, et les variantes /mcp et /api/platform/v1
Enregistrement dynamique (RFC 7591) POST https://strikespace.net/oauth/register
Autorisation GET https://strikespace.net/oauth/authorize
Jetons POST https://strikespace.net/oauth/token
Révocation (RFC 7009) POST https://strikespace.net/oauth/revoke

1. Découverte

Un appel sans jeton à /mcp ou à l'API répond 401 avec WWW-Authenticate: Bearer resource_metadata="https://strikespace.net/.well-known/oauth-protected-resource". Le client lit ce document, puis celui du serveur d'autorisation :

GET /.well-known/oauth-protected-resource
{
  "resource": "https://strikespace.net/mcp",
  "authorization_servers": [
    "https://strikespace.net"
  ],
  "scopes_supported": [
    "leads:read",
    "leads:write",
    "events:read",
    "events:write",
    "segments:read",
    "funnels:read",
    "campaigns:read",
    "campaigns:write",
    "journeys:read",
    "journeys:write",
    "social:read",
    "social:write",
    "social:publish",
    "payments:read",
    "webhooks:manage"
  ],
  "bearer_methods_supported": [
    "header"
  ],
  "resource_name": "STRIKE — serveur MCP",
  "resource_documentation": "https://strikespace.net/developpeurs"
}
GET /.well-known/oauth-authorization-server
{
  "issuer": "https://strikespace.net",
  "authorization_endpoint": "https://strikespace.net/oauth/authorize",
  "token_endpoint": "https://strikespace.net/oauth/token",
  "registration_endpoint": "https://strikespace.net/oauth/register",
  "revocation_endpoint": "https://strikespace.net/oauth/revoke",
  "scopes_supported": [
    "leads:read",
    "leads:write",
    "events:read",
    "events:write",
    "segments:read",
    "funnels:read",
    "campaigns:read",
    "campaigns:write",
    "journeys:read",
    "journeys:write",
    "social:read",
    "social:write",
    "social:publish",
    "payments:read",
    "webhooks:manage"
  ],
  "response_types_supported": [
    "code"
  ],
  "response_modes_supported": [
    "query"
  ],
  "grant_types_supported": [
    "authorization_code",
    "refresh_token"
  ],
  "token_endpoint_auth_methods_supported": [
    "none",
    "client_secret_post",
    "client_secret_basic"
  ],
  "revocation_endpoint_auth_methods_supported": [
    "none",
    "client_secret_post",
    "client_secret_basic"
  ],
  "code_challenge_methods_supported": [
    "S256"
  ],
  "authorization_response_iss_parameter_supported": true,
  "service_documentation": "https://strikespace.net/developpeurs",
  "ui_locales_supported": [
    "fr"
  ]
}

2. Enregistrement du client

L'enregistrement dynamique crée des clients publics (token_endpoint_auth_method: "none", PKCE obligatoire). Les URI de redirection doivent être en https, une adresse de bouclage http://localhost, http://127.0.0.1 ou http://[::1] (tout port), ou un schéma personnalisé d'application native ; 10 au maximum. L'enregistrement est limité à 20 par heure et par adresse IP.

curl
curl -X POST 'https://strikespace.net/oauth/register' \
  -H "Content-Type: application/json" \
  -d '{
    "client_name": "Mon agent interne",
    "redirect_uris": ["http://127.0.0.1:33418/callback"],
    "grant_types": ["authorization_code", "refresh_token"],
    "response_types": ["code"],
    "token_endpoint_auth_method": "none"
  }'

La réponse contient votre client_id (stc_…). Les clients enregistrés dynamiquement sont signalés comme « application non vérifiée » sur la page de consentement.

3. Autorisation avec PKCE

Générez un code_verifier aléatoire, dérivez code_challenge = BASE64URL(SHA256(code_verifier)) (méthode S256, la seule acceptée), puis redirigez l'utilisateur :

HTTP
GET /oauth/authorize?response_type=code
  &client_id=stc_votre_client
  &redirect_uri=http%3A%2F%2F127.0.0.1%3A33418%2Fcallback
  &scope=leads%3Aread%20events%3Awrite
  &state=8c1f0a9e
  &code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM
  &code_challenge_method=S256
  &resource=https%3A%2F%2Fstrikespace.net%2Fmcp

L'utilisateur se connecte à STRIKE si besoin, voit le nom de l'application, le domaine de redirection, le compte concerné et les scopes demandés, et peut décocher ceux qu'il refuse. Seuls les comptes Pro et Enterprise peuvent approuver. STRIKE redirige ensuite vers votre redirect_uri (correspondance exacte) avec code et le state d'origine. Le code est à usage unique et expire après 10 minutes.

4. Échange et renouvellement des jetons

curl
# Échange du code contre des jetons
curl -X POST 'https://strikespace.net/oauth/token' \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d grant_type=authorization_code \
  -d code=stk_ac_recu_sur_le_callback \
  -d redirect_uri=http://127.0.0.1:33418/callback \
  -d client_id=stc_votre_client \
  -d code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk \
  -d resource=https://strikespace.net/mcp

# Renouvellement (le refresh token est remplacé à chaque appel)
curl -X POST 'https://strikespace.net/oauth/token' \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d grant_type=refresh_token \
  -d refresh_token=stk_rt_votre_refresh_token \
  -d client_id=stc_votre_client
Réponse 200
{
  "access_token": "stk_at_…",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "stk_rt_…",
  "scope": "leads:read events:write"
}
  • Durées : jeton d'accès 1 heure, jeton de renouvellement 30 jours.
  • Rotation : chaque renouvellement délivre un nouveau refresh_token et invalide le précédent. Réutiliser un refresh token déjà échangé est traité comme un vol : toute la connexion de l'agent est révoquée.
  • Révocation : POST /oauth/revoke avec le refresh token déconnecte l'agent. L'utilisateur peut aussi le déconnecter depuis Développeurs → Agents IA.

Liaison du jeton à une ressource (RFC 8707)

Un jeton n'est valable que pour la ressource pour laquelle il a été émis. Par défaut, c'est le serveur MCP https://strikespace.net/mcp. Pour appeler l'API REST avec un jeton OAuth, envoyez resource=https://strikespace.net/api/platform/v1 à /oauth/authorize et à /oauth/token ; sinon le jeton est refusé (401) sur /api/platform/v1.

Un agent agit au nom de la personne qui l'a approuvé, avec son rôle dans l'équipe : les publications créées par l'agent d'un membre de l'équipe passent toujours en validation. Si cette personne quitte l'équipe, l'agent perd l'accès.

Erreurs d'authentification

401 authentication_error : en-tête absent, clé ou jeton invalide, expiré, révoqué, ou lié à une autre ressource.
403 permission_error avec code : insufficient_scope (scope manquant), plan_required (offre inférieure à Pro), ip_not_allowed (IP hors liste).

Une question sur l'intégration ? Écrivez à contact@strike.app en indiquant l'endpoint, l'heure et le request_id de la réponse.