Téléversez des fichiers via l’API avec une URL présignée, puis associez-les à des ressources Whop.
Téléversez des fichiers sur Whop pour les utiliser dans des cours, des forums, des profils, des litiges, et plus encore.
Fonctionnement des téléversements
Le téléversement se déroule en deux étapes, et le SDK vous aide pour la première :
Créez un enregistrement de fichier.files.create renvoie l’id du nouveau fichier ainsi qu’une upload_url présignée et les upload_headers à envoyer avec.
Envoyez vous-même les octets. Effectuez un PUT du contenu du fichier vers upload_url avec ces en-têtes. Le SDK ne transfère pas les octets à votre place.
Une fois les octets reçus, le fichier est traité et son upload_status passe à ready. Utilisez files.retrieve pour interroger le fichier jusqu’à ce qu’il soit ready, puis associez l’id à une ressource et lisez l’url finale.Pour téléverser directement depuis le navigateur afin que les octets ne transitent jamais par votre serveur, ou pour envoyer un fichier volumineux en plusieurs parties, consultez Téléverser des fichiers directement.
Initialiser le SDK
import { WhopClient } from "@whop/sdk";const client = new WhopClient({ token: process.env.WHOP_API_KEY,});
use whop_sdk::prelude::*;let config = ClientConfig { token: Some(std::env::var("WHOP_API_KEY").expect("WHOP_API_KEY is not set")), ..Default::default()};let client = Whop::new(config).expect("Failed to build client");
Téléverser un fichier
Créez l’enregistrement, puis effectuez un PUT des octets vers l’URL présignée renvoyée.
import { readFile } from "node:fs/promises";// 1. Create the file record and get a presigned upload URLconst file = await client.files.create({ filename: "photo.jpg" });// 2. Send the bytes to storage yourselfconst bytes = await readFile("./photo.jpg");await fetch(file.upload_url!, { method: "PUT", headers: file.upload_headers as Record<string, string>, body: bytes,});console.log(file.id); // file_xxxxxxxxxxxxx — attach it once it's ready
import requests# 1. Create the file record and get a presigned upload URLfile = client.files.create(filename="photo.jpg")# 2. Send the bytes to storage yourselfwith open("./photo.jpg", "rb") as contents: requests.put( file.upload_url, headers=file.upload_headers or {}, data=contents, )print(file.id) # file_xxxxxxxxxxxxx — attach it once it's ready
require "net/http"# 1. Create the file record and get a presigned upload URLfile = client.files.create(filename: "photo.jpg")# 2. Send the bytes to storage yourselfuri = URI(file.upload_url)request = Net::HTTP::Put.new(uri)(file.upload_headers || {}).each { |key, value| request[key] = value }request.body = File.binread("./photo.jpg")Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }puts file.id # file_xxxxxxxxxxxxx — attach it once it's ready
import ( "bytes" "fmt" "net/http" "os")// 1. Create the file record and get a presigned upload URLfile, err := client.Files.Create(context.TODO(), &whopsdk.CreateFilesRequest{ Filename: "photo.jpg",})if err != nil { return err}// 2. Send the bytes to storage yourselfdata, err := os.ReadFile("./photo.jpg")if err != nil { return err}request, err := http.NewRequest(http.MethodPut, *file.UploadURL, bytes.NewReader(data))if err != nil { return err}for key, value := range file.UploadHeaders { request.Header.Set(key, fmt.Sprint(value))}if _, err := http.DefaultClient.Do(request); err != nil { return err}fmt.Println(file.ID) // file_xxxxxxxxxxxxx — attach it once it's ready
// 1. Create the file record and get a presigned upload URLlet file = client .files .create( &CreateFilesRequest { filename: "photo.jpg".to_string(), ..Default::default() }, None, ) .await?;// 2. Send the bytes to storage yourselflet contents = std::fs::read("./photo.jpg")?;let mut request = reqwest::Client::new() .put(file.upload_url.as_deref().unwrap()) .body(contents);if let Some(headers) = &file.upload_headers { for (key, value) in headers { if let Some(value) = value.as_str() { request = request.header(key, value); } }}request.send().await?;println!("{}", file.id); // file_xxxxxxxxxxxxx — attach it once it's ready
Fichiers publics et privés
Chaque fichier que vous téléversez possède une visibilité qui contrôle son accès. Vous choisissez la visibilité au moment du téléversement et ne pouvez pas la modifier ensuite.
Visibilité
Type d’URL
Qui peut y accéder
À utiliser pour
private (par défaut)
URL signée qui expire
Uniquement votre application, via l’API
Pièces jointes de messages, documents téléversés par les utilisateurs, contenus sensibles, fichiers générés par IA
public
URL permanente et non signée du réseau de diffusion de contenu
Toute personne disposant du lien
Images de produits, miniatures, éléments de marque, ressources marketing
Définissez la visibilité avant de téléverser. Les fichiers publics sont mis en cache sur le CDN de Whop et accessibles à toute personne disposant de l’URL — il est impossible de révoquer l’accès. Si le contenu est propre à un utilisateur ou sensible, conservez la valeur par défaut private.
Téléverser un fichier public
Transmettez une visibilité public lors de la création du fichier, puis téléversez les octets de la même manière :
const file = await client.files.create({ filename: "product-cover.jpg", visibility: "public",});// PUT the bytes to file.upload_url, then file.url is a permanent CDN URL
file = client.files.create( filename="product-cover.jpg", visibility="public",)# PUT the bytes to file.upload_url, then file.url is a permanent CDN URL
file = client.files.create( filename: "product-cover.jpg", visibility: "public",)# PUT the bytes to file.upload_url, then file.url is a permanent CDN URL
file, err := client.Files.Create(context.TODO(), &whopsdk.CreateFilesRequest{ Filename: "product-cover.jpg", Visibility: whopsdk.CreateFilesRequestVisibilityPublic.Ptr(),})// PUT the bytes to file.UploadURL, then file.URL is a permanent CDN URL
let file = client .files .create( &CreateFilesRequest { filename: "product-cover.jpg".to_string(), visibility: Some(CreateFilesRequestVisibility::Public), ..Default::default() }, None, ) .await?;// PUT the bytes to file.upload_url, then file.url is a permanent CDN URL
Associer un fichier à une ressource le déplace vers le stockage correspondant à la visibilité de cette ressource. Une visibility explicite compte surtout pour les fichiers vers lesquels vous créez un lien direct sans les associer.
Confirmer la fin du téléversement
Une fois les octets reçus, le fichier est traité de manière asynchrone. Récupérez-le jusqu’à ce que upload_status quitte pending et processing. Lorsqu’il vaut ready, lisez l’url finale. Lorsqu’il vaut failed, arrêtez-vous et remontez l’erreur.
Identifiant unique (par exemple file_xxxxxxxxxxxxx)
filename
Nom de fichier d’origine
content_type
Type de média (par exemple image/jpeg), déduit de l’extension du nom de fichier
size
Taille du fichier en octets. null jusqu’à la fin du téléversement
url
Emplacement de téléchargement du fichier : une URL permanente du réseau de diffusion de contenu s’il est public, une URL signée qui expire s’il est privé. null jusqu’à la fin du téléversement
upload_status
Statut : pending, processing, ready ou failed
visibility
public ou private
upload_url
Une URL présignée vers laquelle effectuer le PUT des octets. Présente uniquement dans la réponse de create
upload_headers
En-têtes à envoyer avec le PUT de téléversement. Présents uniquement dans la réponse de create
Assistant
Responses are generated using AI and may contain mistakes.