Sube archivos a través de la API con una URL prefirmada y luego adjúntalos a recursos de Whop.
Sube archivos a Whop para usarlos en cursos, foros, perfiles, disputas y más.
Cómo funcionan las subidas
La subida es un flujo de dos pasos, y el SDK ayuda con el primero:
Crea un registro de archivo.files.create devuelve el id del nuevo archivo, además de una upload_url prefirmada y los upload_headers que debes enviar con ella.
Envía los bytes tú mismo. Haz un PUT del contenido del archivo a upload_url con esos encabezados. El SDK no transfiere los bytes por ti.
Una vez que llegan los bytes, el archivo se procesa y su upload_status pasa a ready. Usa files.retrieve para consultar periódicamente hasta que esté en ready y, después, adjunta el id a un recurso y lee la url final.Para subir directamente desde el navegador sin que los bytes pasen por tu servidor, o para enviar un archivo grande por partes, consulta Subir archivos directamente.
Inicializar el 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");
Subir un archivo
Crea el registro y luego haz un PUT de los bytes a la URL prefirmada que se devuelve.
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
Archivos públicos y privados
Cada archivo que subes tiene una visibilidad que controla el acceso. Eliges la visibilidad en el momento de la subida y no puedes cambiarla después.
Visibilidad
Tipo de URL
Quién puede acceder
Uso
private (predeterminado)
URL firmada que caduca
Solo tu app, a través de la API
Adjuntos de mensajes, documentos subidos por usuarios, contenido sensible, archivos generados por IA
public
URL de red de distribución de contenido permanente y sin firmar
Cualquiera que tenga el enlace
Imágenes de productos, miniaturas, branding, recursos de marketing
Establece la visibilidad antes de subir. Los archivos públicos se almacenan en caché en la CDN de Whop y cualquiera que tenga la URL puede acceder a ellos; no hay forma de revocar el acceso. Si el contenido es específico de un usuario o sensible, mantén el valor predeterminado private.
Subir un archivo público
Pasa una visibilidad public al crear el archivo y luego sube los bytes de la misma forma:
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
Adjuntar un archivo a un recurso lo mueve al almacenamiento que corresponde a la visibilidad propia de ese recurso. Una visibility explícita importa sobre todo para los archivos que enlazas directamente sin adjuntarlos.
Confirmar que la subida ha terminado
Después de que lleguen los bytes, el archivo se procesa de forma asíncrona. Obtenlo hasta que upload_status deje de ser pending y processing. Cuando sea ready, lee la url final. Cuando sea failed, detente y muestra el error.
Tipo de medio (p. ej., image/jpeg), deducido de la extensión del nombre del archivo
size
Tamaño del archivo en bytes. null hasta que termina la subida
url
Dónde descargar el archivo: una URL de red de distribución de contenido permanente si es público, una URL firmada que caduca si es privado. null hasta que termina la subida
upload_status
Estado: pending, processing, ready o failed
visibility
public o private
upload_url
Una URL prefirmada a la que hacer PUT de los bytes. Solo presente en la respuesta de create
upload_headers
Encabezados que enviar con el PUT de subida. Solo presentes en la respuesta de create
Assistant
Responses are generated using AI and may contain mistakes.