Financial-grade-API-Client (FAPI 2.0)
Einen Client an das FAPI 2.0 Security Profile anpassen: Private Key JWT, Pushed Authorization Requests und sender-gebundene Token per DPoP.
Hinweis: Verfügbar mit dem Advanced- und Pro-Abonnement.
Wird eine Anwendung auf das FAPI 2.0 Security Profile umgestellt, ändert sich, was ihr Client senden muss. Ein Client, der vorher funktionierte, hört auf zu funktionieren: Das Profil ersetzt das Client-Secret durch eine signierte Assertion, verlangt, dass der Authorisierungs-Request zuerst über einen Back-Channel übermittelt wird, und stellt Access Token aus, die an einen Schlüssel des Clients gebunden sind.
Diese Anleitung behandelt nur die Unterschiede zum Authorization-Code-Flow mit PKCE. Lesen Sie diese Anleitung zuerst.
Was sich ändert
| Standard-Client | FAPI-2.0-Client | |
|---|---|---|
| Client-Authentifizierung | Client-Secret | Private Key JWT, mit PS256 signiert |
| Authorisierungs-Request | Parameter in der Browser-URL | Zuerst übermittelt, Browser erhält eine request_uri |
| PKCE | Empfohlen | Erforderlich, S256 |
| Access Token | Bearer | DPoP, an Ihren Schlüssel gebunden |
| Token-Requests | Ein Aufruf | Zwei beim ersten Kontakt, wegen der DPoP-Nonce |
Bevor Sie beginnen
-
Erzeugen Sie ein Schlüsselpaar für die Client-Authentifizierung. RSA (mindestens 2048 Bit) oder EC auf der Kurve P-256.
-
Hinterlegen Sie den öffentlichen Schlüssel an der Anwendung und schalten Sie sie dann auf das FAPI-2.0-Profil um. Die einzuhaltende Reihenfolge steht unter Financial-grade API security.
-
Erzeugen Sie ein zweites Schlüsselpaar für die DPoP-Proofs. Halten Sie es getrennt vom Schlüssel der Client-Authentifizierung, damit jeder Schlüssel genau eine Aufgabe hat.
-
Lesen Sie das Discovery-Dokument. Es führt jetzt zusätzlich
pushed_authorization_request_endpoint, unddpop_signing_alg_values_supportednennt die für Proofs zulässigen Algorithmen.https://<your-domain>/.well-known/openid-configuration
Stellt die von Ihrer Anwendung aufgerufene API JWT-Access-Token aus, setzen Sie auch deren Signing Algorithm auf PS256. Siehe APIs.
1. Eine Client Assertion erzeugen
Jeder Aufruf, der bisher das Client-Secret trug, trägt jetzt ein kurzlebiges JWT, signiert mit dem privaten Schlüssel Ihrer Client-Authentifizierung. Die Beispiele verwenden die JOSE-Bibliothek des jeweiligen Stacks: jose für Node.js, PyJWT (mit dem crypto-Extra) für Python, Nimbus JOSE + JWT für Java, Microsoft.IdentityModel.JsonWebTokens für C#, lestrrat-go/jwx für Go, web-token/jwt-framework für PHP und josekit für Rust.
import * as jose from 'jose';
const ISSUER = 'https://<your-domain>';
const CLIENT_ID = '<your-client-id>';
// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
const authKey = await jose.importPKCS8(process.env.CLIENT_AUTH_PRIVATE_KEY, 'PS256');
const KID = '<key-id-from-the-console>';
function clientAssertion() {
return new jose.SignJWT({ jti: crypto.randomUUID() })
.setProtectedHeader({ alg: 'PS256', kid: KID, typ: 'JWT' })
.setIssuer(CLIENT_ID)
.setSubject(CLIENT_ID)
.setAudience(ISSUER) // the issuer identifier, not the endpoint URL
.setIssuedAt()
.setExpirationTime('2m')
.sign(authKey);
}import os
import time
import uuid
import jwt
ISSUER = "https://<your-domain>"
CLIENT_ID = "<your-client-id>"
# Your client-authentication private key, plus the key id shown next to the
# registered key in the Admin Console.
AUTH_KEY = os.environ["CLIENT_AUTH_PRIVATE_KEY"]
KID = "<key-id-from-the-console>"
def client_assertion():
now = int(time.time())
return jwt.encode(
{
"jti": str(uuid.uuid4()),
"iss": CLIENT_ID,
"sub": CLIENT_ID,
"aud": ISSUER, # the issuer identifier, not the endpoint URL
"iat": now,
"exp": now + 120,
},
AUTH_KEY,
algorithm="PS256",
headers={"kid": KID},
)import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.RSASSASigner;
import com.nimbusds.jose.jwk.JWK;
import com.nimbusds.jwt.JWTClaimsSet;
import com.nimbusds.jwt.SignedJWT;
import java.time.Instant;
import java.util.Date;
import java.util.UUID;
static final String ISSUER = "https://<your-domain>";
static final String CLIENT_ID = "<your-client-id>";
// The key id shown next to the registered key in the Admin Console.
static final String KID = "<key-id-from-the-console>";
static String clientAssertion() throws Exception {
// Your client-authentication private key
var authKey = JWK.parseFromPEMEncodedObjects(System.getenv("CLIENT_AUTH_PRIVATE_KEY")).toRSAKey();
var claims = new JWTClaimsSet.Builder()
.jwtID(UUID.randomUUID().toString())
.issuer(CLIENT_ID)
.subject(CLIENT_ID)
.audience(ISSUER) // the issuer identifier, not the endpoint URL
.issueTime(new Date())
.expirationTime(Date.from(Instant.now().plusSeconds(120)))
.build();
var jwt = new SignedJWT(
new JWSHeader.Builder(JWSAlgorithm.PS256).keyID(KID).type(JOSEObjectType.JWT).build(),
claims);
jwt.sign(new RSASSASigner(authKey));
return jwt.serialize();
}using System.Security.Cryptography;
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;
const string Issuer = "https://<your-domain>";
const string ClientId = "<your-client-id>";
// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
var authRsa = RSA.Create();
authRsa.ImportFromPem(Environment.GetEnvironmentVariable("CLIENT_AUTH_PRIVATE_KEY"));
var authKey = new RsaSecurityKey(authRsa) { KeyId = "<key-id-from-the-console>" };
string ClientAssertion() => new JsonWebTokenHandler().CreateToken(new SecurityTokenDescriptor
{
Issuer = ClientId,
Audience = Issuer, // the issuer identifier, not the endpoint URL
Claims = new Dictionary<string, object> { ["sub"] = ClientId, ["jti"] = Guid.NewGuid().ToString() },
Expires = DateTime.UtcNow.AddMinutes(2),
SigningCredentials = new SigningCredentials(authKey, SecurityAlgorithms.RsaSsaPssSha256), // PS256
});import (
"os"
"time"
"github.com/google/uuid"
"github.com/lestrrat-go/jwx/v2/jwa"
"github.com/lestrrat-go/jwx/v2/jwk"
"github.com/lestrrat-go/jwx/v2/jwt"
)
const issuer = "https://<your-domain>"
const clientID = "<your-client-id>"
// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
var authKey, _ = jwk.ParseKey([]byte(os.Getenv("CLIENT_AUTH_PRIVATE_KEY")), jwk.WithPEM(true))
const kid = "<key-id-from-the-console>"
func clientAssertion() []byte {
authKey.Set(jwk.KeyIDKey, kid)
token, _ := jwt.NewBuilder().
JwtID(uuid.NewString()).
Issuer(clientID).
Subject(clientID).
Audience([]string{issuer}). // the issuer identifier, not the endpoint URL
IssuedAt(time.Now()).
Expiration(time.Now().Add(2*time.Minute)).
Build()
signed, _ := jwt.Sign(token, jwt.WithKey(jwa.PS256, authKey))
return signed
}use Jose\Component\Core\AlgorithmManager;
use Jose\Component\KeyManagement\JWKFactory;
use Jose\Component\Signature\Algorithm\PS256;
use Jose\Component\Signature\JWSBuilder;
use Jose\Component\Signature\Serializer\CompactSerializer;
const ISSUER = 'https://<your-domain>';
const CLIENT_ID = '<your-client-id>';
const KID = '<key-id-from-the-console>';
// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
$authKey = JWKFactory::createFromKey(getenv('CLIENT_AUTH_PRIVATE_KEY'));
function clientAssertion($authKey): string {
$jws = (new JWSBuilder(new AlgorithmManager([new PS256()])))
->create()
->withPayload(json_encode([
'jti' => bin2hex(random_bytes(16)),
'iss' => CLIENT_ID,
'sub' => CLIENT_ID,
'aud' => ISSUER, // the issuer identifier, not the endpoint URL
'iat' => time(),
'exp' => time() + 120,
]))
->addSignature($authKey, ['alg' => 'PS256', 'kid' => KID, 'typ' => 'JWT'])
->build();
return (new CompactSerializer())->serialize($jws);
}use std::env;
use std::time::{Duration, SystemTime};
use josekit::jws::{JwsHeader, PS256};
use josekit::jwt::{self, JwtPayload};
use uuid::Uuid;
const ISSUER: &str = "https://<your-domain>";
const CLIENT_ID: &str = "<your-client-id>";
// The key id shown next to the registered key in the Admin Console.
const KID: &str = "<key-id-from-the-console>";
fn client_assertion() -> String {
let mut header = JwsHeader::new();
header.set_key_id(KID);
header.set_token_type("JWT");
let mut payload = JwtPayload::new();
payload.set_jwt_id(Uuid::new_v4().to_string());
payload.set_issuer(CLIENT_ID);
payload.set_subject(CLIENT_ID);
payload.set_audience(vec![ISSUER]); // the issuer identifier, not the endpoint URL
payload.set_issued_at(&SystemTime::now());
payload.set_expires_at(&(SystemTime::now() + Duration::from_secs(120)));
// Your client-authentication private key
let signer = PS256.signer_from_pem(env::var("CLIENT_AUTH_PRIVATE_KEY").unwrap()).unwrap();
jwt::encode_with_signer(&payload, &header, &signer).unwrap()
}Zwei Details entscheiden, ob das akzeptiert wird:
audmuss die Issuer-Kennung sein. Ohne Profil wird auch die Endpunkt-URL akzeptiert, unter FAPI 2.0 nicht.algmuss PS256 sein. Das Profil legt den Signaturalgorithmus für die Assertions der Anwendung fest.
Senden Sie sie bei jedem Token- und Pushed-Authorization-Request als zwei Formularfelder:
client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
client_assertion=<the JWT>2. Den Authorisierungs-Request übermitteln
Statt die Parameter in die Browser-URL zu schreiben, senden Sie sie per POST an den Pushed-Authorization-Endpunkt. Die Antwort ist eine einmalig verwendbare Referenz.
curl -X POST https://<your-domain>/oauth/par \
-d client_id=<your-client-id> \
-d response_type=code \
-d redirect_uri=https://app.example.com/callback \
-d scope='openid profile' \
-d code_challenge=<CODE_CHALLENGE> \
-d code_challenge_method=S256 \
-d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer \
-d client_assertion=<the JWT>Ein erfolgreicher Aufruf antwortet mit 201 und:
{
"request_uri": "urn:ietf:params:oauth:request_uri:...",
"expires_in": 60
}redirect_urimuss immer mitgesendet werden, auch wenn an der Anwendung genau eine registriert ist. Das Profil entfernt die Abkürzung, sie weglassen zu können.- PKCE ist hier verpflichtend, mit
code_challenge_method=S256. Ein übermittelter Request ohne Challenge wird abgelehnt. - Die
request_uriist einmalig verwendbar und verfällt innerhalb einer Minute. Übermitteln Sie den Request, wenn der Benutzer unmittelbar weitergeleitet wird, nicht vorab.
3. Den Benutzer an den Authorisierungs-Endpunkt senden
Die Browser-URL trägt jetzt nur noch die Client-ID und die Referenz:
https://<your-domain>/authorize
?client_id=<your-client-id>
&request_uri=urn%3Aietf%3Aparams%3Aoauth%3Arequest_uri%3A...Die Plattform leitet den Benutzer mit code, state und einem iss-Parameter, der den Issuer nennt, an Ihre Redirect-URI zurück. Prüfen Sie iss ebenso wie state, bevor Sie fortfahren; das schützt davor, dass eine Antwort von einem anderen Issuer wiedereingespielt wird.
4. Einen DPoP-Proof erstellen
Ein DPoP-Proof ist ein JWT, signiert mit Ihrem privaten DPoP-Schlüssel, das den öffentlichen Schlüssel in seinem Header trägt. Es ist an genau einen Request gebunden: Methode und URL stehen darin.
const dpopKey = await jose.importPKCS8(process.env.DPOP_PRIVATE_KEY, 'ES256');
const dpopPublicJwk = await jose.exportJWK(await jose.importSPKI(process.env.DPOP_PUBLIC_KEY, 'ES256'));
function dpopProof(method, url, nonce) {
return new jose.SignJWT({ jti: crypto.randomUUID(), htm: method, htu: url, ...(nonce ? { nonce } : {}) })
.setProtectedHeader({ alg: 'ES256', typ: 'dpop+jwt', jwk: dpopPublicJwk })
.setIssuedAt()
.sign(dpopKey);
}from cryptography.hazmat.primitives.serialization import load_pem_private_key
from jwt.algorithms import ECAlgorithm
dpop_key = load_pem_private_key(os.environ["DPOP_PRIVATE_KEY"].encode(), password=None)
dpop_public_jwk = ECAlgorithm.to_jwk(dpop_key.public_key(), as_dict=True)
def dpop_proof(method, url, nonce=None):
claims = {"jti": str(uuid.uuid4()), "htm": method, "htu": url, "iat": int(time.time())}
if nonce:
claims["nonce"] = nonce
return jwt.encode(
claims, dpop_key,
algorithm="ES256",
headers={"typ": "dpop+jwt", "jwk": dpop_public_jwk},
)import com.nimbusds.jose.crypto.ECDSASigner;
static String dpopProof(String method, String url, String nonce) throws Exception {
var dpopKey = JWK.parseFromPEMEncodedObjects(System.getenv("DPOP_PRIVATE_KEY")).toECKey();
var claims = new JWTClaimsSet.Builder()
.jwtID(UUID.randomUUID().toString())
.claim("htm", method)
.claim("htu", url)
.issueTime(new Date());
if (nonce != null) claims.claim("nonce", nonce);
var jwt = new SignedJWT(
new JWSHeader.Builder(JWSAlgorithm.ES256)
.type(new JOSEObjectType("dpop+jwt"))
.jwk(dpopKey.toPublicJWK())
.build(),
claims.build());
jwt.sign(new ECDSASigner(dpopKey));
return jwt.serialize();
}var dpopEc = ECDsa.Create();
dpopEc.ImportFromPem(Environment.GetEnvironmentVariable("DPOP_PRIVATE_KEY"));
var dpopKey = new ECDsaSecurityKey(dpopEc);
var publicJwk = JsonWebKeyConverter.ConvertFromECDsaSecurityKey(
new ECDsaSecurityKey(ECDsa.Create(dpopEc.ExportParameters(includePrivateParameters: false))));
string DpopProof(string method, string url, string? nonce = null)
{
var claims = new Dictionary<string, object> { ["jti"] = Guid.NewGuid().ToString(), ["htm"] = method, ["htu"] = url };
if (nonce is not null) claims["nonce"] = nonce;
return new JsonWebTokenHandler().CreateToken(new SecurityTokenDescriptor
{
TokenType = "dpop+jwt",
Claims = claims,
SigningCredentials = new SigningCredentials(dpopKey, SecurityAlgorithms.EcdsaSha256), // ES256
AdditionalHeaderClaims = new Dictionary<string, object>
{
["jwk"] = new Dictionary<string, string>
{
["kty"] = publicJwk.Kty, ["crv"] = publicJwk.Crv, ["x"] = publicJwk.X, ["y"] = publicJwk.Y,
},
},
});
}import "github.com/lestrrat-go/jwx/v2/jws"
var dpopKey, _ = jwk.ParseKey([]byte(os.Getenv("DPOP_PRIVATE_KEY")), jwk.WithPEM(true))
func dpopProof(method, url, nonce string) []byte {
dpopPublicJwk, _ := dpopKey.PublicKey()
builder := jwt.NewBuilder().
JwtID(uuid.NewString()).
Claim("htm", method).
Claim("htu", url).
IssuedAt(time.Now())
if nonce != "" {
builder = builder.Claim("nonce", nonce)
}
token, _ := builder.Build()
headers := jws.NewHeaders()
headers.Set("typ", "dpop+jwt")
headers.Set("jwk", dpopPublicJwk)
signed, _ := jwt.Sign(token, jwt.WithKey(jwa.ES256, dpopKey, jws.WithProtectedHeaders(headers)))
return signed
}use Jose\Component\Signature\Algorithm\ES256;
$dpopKey = JWKFactory::createFromKey(getenv('DPOP_PRIVATE_KEY'));
function dpopProof($dpopKey, string $method, string $url, ?string $nonce = null): string {
$claims = ['jti' => bin2hex(random_bytes(16)), 'htm' => $method, 'htu' => $url, 'iat' => time()];
if ($nonce !== null) {
$claims['nonce'] = $nonce;
}
$jws = (new JWSBuilder(new AlgorithmManager([new ES256()])))
->create()
->withPayload(json_encode($claims))
->addSignature($dpopKey, ['alg' => 'ES256', 'typ' => 'dpop+jwt', 'jwk' => $dpopKey->toPublic()])
->build();
return (new CompactSerializer())->serialize($jws);
}use josekit::jws::ES256;
fn dpop_proof(method: &str, url: &str, nonce: Option<&str>) -> String {
let pem = env::var("DPOP_PRIVATE_KEY").unwrap();
let key_pair = ES256.key_pair_from_pem(&pem).unwrap();
let mut header = JwsHeader::new();
header.set_token_type("dpop+jwt");
header.set_jwk(key_pair.to_jwk_public_key());
let mut payload = JwtPayload::new();
payload.set_jwt_id(Uuid::new_v4().to_string());
payload.set_claim("htm", Some(method.into())).unwrap();
payload.set_claim("htu", Some(url.into())).unwrap();
payload.set_issued_at(&SystemTime::now());
if let Some(nonce) = nonce {
payload.set_claim("nonce", Some(nonce.into())).unwrap();
}
let signer = ES256.signer_from_pem(&pem).unwrap();
jwt::encode_with_signer(&payload, &header, &signer).unwrap()
}htu ist die Endpunkt-URL ohne Query und Fragment und muss der tatsächlich aufgerufenen URL entsprechen, inklusive Schema und Host.
5. Den Code eintauschen, zweimal
Eine Server-Nonce ist erforderlich, daher scheitert der erste Token-Request immer. Das ist erwartetes Verhalten und kein Fehler in Ihrer Einrichtung: Die Antwort liefert die Nonce für den nächsten Proof.
# First attempt: no nonce yet
curl -i -X POST https://<your-domain>/oauth/token \
-H 'DPoP: <proof without nonce>' \
-d grant_type=authorization_code \
-d code=<one-time-code> \
-d redirect_uri=https://app.example.com/callback \
-d code_verifier=<CODE_VERIFIER> \
-d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer \
-d client_assertion=<the JWT>Die Antwort ist ein 400 mit {"error":"use_dpop_nonce"} und einem DPoP-Nonce-Response-Header. Lesen Sie diesen Header, erstellen Sie einen neuen Proof mit dem Wert als nonce-Claim und wiederholen Sie denselben Request:
let res = await tokenRequest(dpopProof('POST', tokenUrl));
if (!res.ok) {
const nonce = res.headers.get('dpop-nonce');
res = await tokenRequest(dpopProof('POST', tokenUrl, nonce));
}res = token_request(dpop_proof("POST", token_url))
if not res.ok:
nonce = res.headers.get("dpop-nonce")
res = token_request(dpop_proof("POST", token_url, nonce))var res = tokenRequest(dpopProof("POST", tokenUrl, null));
if (res.statusCode() != 200) {
var nonce = res.headers().firstValue("DPoP-Nonce").orElseThrow();
res = tokenRequest(dpopProof("POST", tokenUrl, nonce));
}var res = await TokenRequest(DpopProof("POST", tokenUrl));
if (!res.IsSuccessStatusCode && res.Headers.TryGetValues("DPoP-Nonce", out var nonces))
{
res = await TokenRequest(DpopProof("POST", tokenUrl, nonces.First()));
}res, _ := tokenRequest(dpopProof("POST", tokenURL, ""))
if res.StatusCode != http.StatusOK {
nonce := res.Header.Get("DPoP-Nonce")
res, _ = tokenRequest(dpopProof("POST", tokenURL, nonce))
}$res = tokenRequest(dpopProof($dpopKey, 'POST', $tokenUrl));
if ($res->getStatusCode() !== 200) {
$nonce = $res->getHeaderLine('DPoP-Nonce');
$res = tokenRequest(dpopProof($dpopKey, 'POST', $tokenUrl, $nonce));
}let mut res = token_request(dpop_proof("POST", token_url, None)).await?;
if !res.status().is_success() {
let nonce = res.headers().get("dpop-nonce").and_then(|v| v.to_str().ok()).map(String::from);
res = token_request(dpop_proof("POST", token_url, nonce.as_deref())).await?;
}Eine Nonce bleibt eine Weile gültig, halten Sie die letzte erhaltene also vor und beginnen Sie den nächsten Request damit. Behandeln Sie use_dpop_nonce jederzeit: Läuft eine Nonce ab, wiederholt sich derselbe Austausch.
Eine erfolgreiche Antwort unterscheidet sich in einem einzigen, wichtigen Punkt von einer gewöhnlichen:
{
"token_type": "DPoP",
"access_token": "...",
"id_token": "...",
"expires_in": 3600
}6. APIs mit dem Token aufrufen
token_type ist DPoP, nicht Bearer, und der Token ist an Ihren DPoP-Schlüssel gebunden. Jeder Aufruf einer Ressource benötigt sowohl den Token als auch einen frischen Proof für diesen Request:
curl https://api.example.com/orders \
-H 'Authorization: DPoP <access_token>' \
-H 'DPoP: <proof for GET https://api.example.com/orders>'Den Token als Authorization: Bearer zu senden schlägt fehl. Eine Ressource, die die Bindung prüft, vergleicht den Schlüssel im Proof mit dem Confirmation-Claim im Token, sodass ein gestohlener Token ohne den privaten Schlüssel nutzlos ist.
Fehlerbehebung
use_dpop_noncebei jedem Request. Dem Proof fehlt dernonce-Claim, oder Sie haben den vorherigen Proof erneut verwendet statt einen neuen zu signieren. Jeder Proof ist einmalig verwendbar.invalid_client, obwohl dieselbe Einrichtung vor dem Profil funktionierte. Entweder istaudder Assertion die Endpunkt-URL statt der Issuer-Kennung, oder sie ist nicht mit PS256 signiert, oder diekidpasst zu keinem hinterlegten Schlüssel.invalid_dpop_proof. Diehtuentspricht nicht der aufgerufenen URL (häufige Ursache: ein Proxy, der den Host umschreibt), oderhtmpasst nicht zur Methode, oder die Uhr weicht um mehr als eine geringe Toleranz ab.invalid_requestam Authorisierungs-Endpunkt. Die Anwendung verlangt einen übermittelten Request, Parameter können also nicht mehr in der Browser-URL gesendet werden. Übermitteln Sie sie zuerst und übergeben Sie dierequest_uri.- Die
request_uriwird als unbekannt abgelehnt. Sie wurde bereits verwendet oder ist verfallen. Übermitteln Sie einen neuen Request. - Die Ressource lehnt den Token ab. Prüfen Sie, ob er mit dem Schema
DPoPgesendet wird und ob die Ressource die Bindung prüft, statt einen Bearer Token zu erwarten.
Siehe auch
- Financial-grade API security für die Einstellungen an der Anwendung und was das Profil erzwingt.
- APIs für den Signaturalgorithmus der Access Token.
- OpenID Connect (Authorization Code + PKCE) für den Basis-Flow.
React-Single-Page-App
Fügen Sie einer React-Browser-App die Anmeldung als Public Client hinzu, mit react-oidc-context und dem Authorization Code Flow mit PKCE.
Eine API schützen
Die Access Token der Plattform in Ihrer eigenen API validieren, mit Beispielen für Node.js, Python, Java, C#, Go, PHP und Rust.