> This page is for Plate-forme, version Hérité. > For other versions, use one of these documentation indexes: > - V4 (default): https://next.developer.frame.io/platform/v4/llms.txt > - V4 expérimental: https://next.developer.frame.io/platform/v4-experimental/llms.txt > - Hérité: https://next.developer.frame.io/platform/v2/llms.txt > For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://next.developer.frame.io/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://next.developer.frame.io/_mcp/server. # Actualisation des jetons OAuth 2 Si ce n'est pas le cas, consultez [ce](/oauth-2-applications/building-an-oauth-2-app) guide et revenez ici une fois que vous avez capturé le `access_token` et le `refresh_token` d'un octroi d'informations d'identification OAuth 2 réussi. ## Principes de base de l'actualisation de jeton En supposant que vous ayez inclus la portée ***offline*** dans votre demande d'informations d'identification OAuth2.0, une authentification réussie via l'application Accounts de Frame.io renverra une charge utile qui ressemble à ceci : ```json { "access_token":"BEARER_TOKEN", "expires_in":3600, "refresh_token":"REFRESH_TOKEN", "scope":"account.read offline", "token_type":"bearer" } ``` Le `access_token` est un jeton porteur qui peut être utilisé pour agir au nom de l'utilisateur authentifié ; il expirera après 3600 secondes (une heure) ; et après cela, le `refresh_token` peut être utilisé pour récupérer un nouveau `access_token`. Le jeton d'actualisation expirera ensuite après 30 jours, moment où vous devrez demander à l'utilisateur de se connecter depuis le début, produisant une nouvelle paire de jetons d'accès/actualisation ; et ainsi de suite. Si vous ne demandez pas explicitement la portée *offline*, vous ne recevrez pas de `refresh_token`, et par conséquent après une heure, vous devrez réauthentifier complètement l'utilisateur. ### Capture du jeton d'actualisation lors d'une authentification réussie Il va sans dire que vous ne pouvez pas utiliser un `refresh_token` que vous n'avez pas, alors assurez-vous dans votre app de : * Demander la portée **offline** * Capturer le `refresh_token` qui est renvoyé dans un rappel réussi. Pour plus de commodité, le rappel de nos [Guides d'app OAuth 2](/oauth-2-applications/building-an-oauth-2-app) est reproduit ici, avec un appel `os` pour stocker le jeton d'actualisation. Veuillez noter que deux exemples sont fournis : un avec PKCE configuré (n'inclut pas d'en-tête d'authentification de base), et un sans (inclut un en-tête d'authentification de base). ### Sans PKCE **`Python`** ```python title="Python" def callback(): # Where `request` refers to our initial call to the auth URL state = request.args.get('state') scope = request.args.get('scope') code = request.args.get('code') error = request.args.get('error') if error: return "Error: " + error # Set up for client authorization and set up the data you need to send. client_auth = requests.auth.HTTPBasicAuth(CLIENT_ID, CLIENT_SECRET) post_data = { "grant_type": "authorization_code", "code": code, "redirect_uri": REDIRECT_URI, "state": state, "scope": SCOPE } # Send a POST request with the data you need to receive an access token. response = requests.post(TOKEN, auth=client_auth, data=post_data) # Stash the refresh token for later os.environ['REFRESH_TOKEN'] = response.json()["refresh_token"] return response.text ``` ### Avec PKCE **`Python`** ```python title="Python" def callback(): # Where `request` refers to our initial call to the auth URL state = request.args.get('state') scope = request.args.get('scope') code = request.args.get('code') error = request.args.get('error') if error: return "Error: " + error # If using PKCE, you must include the CLIENT_ID in your request body post_data = { "grant_type": "authorization_code", "code": code, "redirect_uri": REDIRECT_URI, "state": state, "scope": SCOPE "client_id": CLIENT_ID } # Send a POST request with the data you need to receive an access token. # If using PKCE, use the below request with no auth response = requests.post(TOKEN_URL, data=post_data) # Stash the refresh token for later os.environ['REFRESH_TOKEN'] = response.json()["refresh_token"] return response.text ``` ## Exécution d'une actualisation L'actualisation elle-même est un seul appel à l'URL de jeton de Frame.io : * Méthode : POST * URL : **https://applications.frame.io/oauth2/token** * `Content-Type` : *application/x-www-form-urlencoded* Une actualisation inclura toujours au moins les trois attributs suivants dans les données du formulaire : * `grant_type` : *refresh_token* * `scope` : \<scopes> * `refresh_token` : \<refresh_token> Si vous utilisez PKCE, vous devrez inclure le `client_id` de votre application dans ces données de formulaire ; sinon, vous devrez inclure un en-tête d'authentification basique avec le `client_id` et le `client_secret` de votre application comme nom d'utilisateur et mot de passe, respectivement. ### Sans PKCE Comme pour [effectuer le rappel d'authentification initial](/oauth-2-applications/building-an-oauth-2-app#the-callback) sans PKCE, cette actualisation standard nécessitera de fournir votre `client_id` et `client_secret` comme nom d'utilisateur et mot de passe dans un en-tête d'authentification basique. **`Python`** ```python title="Python" def refresh(): # Fetch the refresh token, assuming we have it REFRESH_TOKEN = os.environ.get('REFRESH_TOKEN') client_auth = requests.auth.HTTPBasicAuth(CLIENT_ID,CLIENT_SECRET) post_data = { "grant_type": "refresh_token", "scope": SCOPE, "refresh_token": REFRESH_TOKEN # if using PKCE, you will need to include your client_id as below # "client_id": CLIENT_ID } response = requests.post(TOKEN_URL, auth=client_auth, data=post_data) # Catch + stash a new Refresh Token os.environ['REFRESH_TOKEN'] = response.json()["refresh_token"] return response.text ``` ### Avec PKCE Encore une fois, nous reproduisons les règles de notre cycle `/callback` initial : * Nous n'incluons pas d'en-tête `Authorization` * Nous devons inclure le `client_id` dans notre charge utile **`Python`** ```python title="Python" def refresh(): # Fetch the refresh token, assuming we have it REFRESH_TOKEN = os.environ.get('REFRESH_TOKEN') post_data = { "grant_type": "refresh_token", "scope": SCOPE, "refresh_token": REFRESH_TOKEN "client_id": CLIENT_ID } response = requests.post(TOKEN_URL, data=post_data) # Catch + stash a new Refresh Token os.environ['REFRESH_TOKEN'] = response.json()["refresh_token"] return response.text ``` Félicitations !Vous pouvez maintenant gérer l'ensemble du cycle de vie des jetons d'une application cliente OAuth2.0.