API publique

Créer une clé

Dans Réglages → API pour développeurs, choisis le drive concerné et génère une clé. Elle n'est affichée qu'une seule fois: copie-la immédiatement dans la configuration de ton site (variable d'environnement, jamais dans du code commité).

Authentification

Toutes les routes sont sous /api/v1 et attendent un en-tête Authorization :

Authorization: Bearer dvc_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Chaque clé est liée à un seul drive et porte des permissions précises : files:read (lecture et téléchargement), files:write (envoi), files:delete (suppression), folders:write (création de dossiers) et public:manage (liens publics). Les anciennes clés read / write continuent de fonctionner : read = files:read, write = toutes les autres.

À la création, tu peux aussi donner une date d'expiration, une liste d'adresses IPautorisées et une liste d'origines webautorisées. Une clé révoquée ou expirée est refusée immédiatement. Si tu appelles l'API depuis un navigateur, restreins la clé à ton site : la réponse CORS renvoie alors l'origine exacte (et non *) et les autres origines sont refusées. Garder la clé côté serveur reste plus sûr.

Vérifier la clé

curl https://ton-domaine.tld/api/v1/me \
  -H "Authorization: Bearer dvc_xxx"

# → { "drive": "Mon site", "driveId": "...", "scopes": ["files:read", "files:write"] }

Uploader un fichier

POST /api/v1/files — multipart/form-data avec un champ file, et optionnellement parentId (dossier cible) et filename.

curl -X POST https://ton-domaine.tld/api/v1/files \
  -H "Authorization: Bearer dvc_xxx" \
  -F "file=@/chemin/vers/fichier.pdf"

Réponse 201 avec les métadonnées du fichier créé (id, filename, size,mimeType…).

Limite de taille (upload simple)

Ce chemin transite par notre serveur en une seule requête : la taille est donc bornée par la limite de requête de l'hébergeur (45 Mio ici). Pour des fichiers plus gros, utilise l'upload par morceaux ci-dessous.

Upload par morceaux (taille illimitée)

Pour dépasser la limite de requête, découpe ton fichier en morceaux d'environ 9 Mio et envoie-les un par un à POST /api/v1/files/chunks (champ chunk, plus indexpour l'ordre), puis finalise avec un appel JSON à POST /api/v1/files contenant l'uploadId renvoyé par le premier morceau. Le serveur retient lui-même chaque morceau reçu : la finalisation ne peut référencer que ce que tu as réellement envoyé à ton drive (une session expire au bout de 24 h, 20 uploads ouverts max par clé). Aucune limite de taille sur ce dernier appel : il ne transporte aucun octet du fichier.

# 1. un POST par morceau (~9 Mio chacun)
curl -X POST https://ton-domaine.tld/api/v1/files/chunks \
  -H "Authorization: Bearer dvc_xxx" \
  -F "index=0" -F "chunk=@part-000"
# → { "uploadId": "...", "index": 0, "size": ..., … }

# … puis les suivants, en réutilisant l'uploadId (index=1, 2, 3…) …
curl -X POST https://ton-domaine.tld/api/v1/files/chunks \
  -H "Authorization: Bearer dvc_xxx" \
  -F "uploadId=<uploadId>" -F "index=1" -F "chunk=@part-001"

# 2. finalise avec la liste des morceaux (JSON, pas de fichier)
curl -X POST https://ton-domaine.tld/api/v1/files \
  -H "Authorization: Bearer dvc_xxx" \
  -H "Content-Type: application/json" \
  -d '{
        "filename": "video.mp4",
        "mimeType": "video/mp4",
        "uploadId": "<uploadId>"
      }'

Lister les fichiers

curl "https://ton-domaine.tld/api/v1/files?parentId=&limit=50" \
  -H "Authorization: Bearer dvc_xxx"

Sans paramètre, la route renvoie les fichiers à la racine du drive. parentId=<id> cible un dossier (voir Dossiers plus bas), limit va de 1 à 200 (100 par défaut).

Listing incrémental (synchronisation)

Pour un client de synchronisation, trois paramètres activent un mode sync, trié par date de modification croissante :

• recursive=1— tout le drive d'un coup, pas seulement un dossier.
• updatedSince=<ms> — uniquement les fichiers modifiés après cet horodatage Unix en millisecondes (comparaison stricte).
• cursor=<valeur> — pagination : réutilise le nextCursorrenvoyé par la page précédente jusqu'à ce qu'il soit null. limit monte à 500 dans ce mode (200 par défaut).

# première synchro complète, page par page
curl "https://ton-domaine.tld/api/v1/files?recursive=1&limit=500" \
  -H "Authorization: Bearer dvc_xxx"
# → { "files": [ … ], "nextCursor": "1717000000000_abc123" | null }

# polls suivants : seulement ce qui a changé depuis le dernier passage
curl "https://ton-domaine.tld/api/v1/files?recursive=1&updatedSince=1717000000000" \
  -H "Authorization: Bearer dvc_xxx"

Dossiers

Les dossiers sont de simples métadonnées (Discord n'a pas cette notion) : les créer ou les supprimer ne touche au stockage Discord que pour les fichiers réellement contenus.

# lister (racine par défaut, ?parentId=<id> pour un sous-dossier,
#         ?recursive=1 pour tout l'arbre d'un coup)
curl "https://ton-domaine.tld/api/v1/folders?recursive=1" \
  -H "Authorization: Bearer dvc_xxx"
# → { "folders": [ { "id": "...", "name": "...", "parentId": "" }, … ] }

# créer  (parentId optionnel — absent = racine)
curl -X POST https://ton-domaine.tld/api/v1/folders \
  -H "Authorization: Bearer dvc_xxx" \
  -H "Content-Type: application/json" \
  -d '{ "name": "Factures", "parentId": "" }'
# → 201 { "id": "...", "name": "Factures", "parentId": "" }

# métadonnées d'un dossier
curl https://ton-domaine.tld/api/v1/folders/abc123 \
  -H "Authorization: Bearer dvc_xxx"

# supprimer — récursif : le dossier, ses sous-dossiers et tous les fichiers
# qu'ils contiennent (messages Discord compris)
curl -X DELETE https://ton-domaine.tld/api/v1/folders/abc123 \
  -H "Authorization: Bearer dvc_xxx"

Pour ranger un fichier dans un dossier à l'upload, passe son id comme parentId(champ du formulaire pour l'upload simple/par morceaux, clé JSON pour la finalisation).

Récupérer un fichier

GET /api/v1/files/:id renvoie les métadonnées. GET /api/v1/files/:id/download renvoie directement les octets du fichier (déchiffrés si besoin), prêts à être servis ou relayés par ton site.

curl https://ton-domaine.tld/api/v1/files/abc123/download \
  -H "Authorization: Bearer dvc_xxx" \
  -o fichier.pdf

Lien public permanent (hotlink)

POST /api/v1/files/:id/public crée un lien public, sans mot de passe, qui n'expire pas — utilisable directement dans un <img src>, une balise <a> ou un fetch(), sans en-tête Authorization. Un seul lien public actif par fichier : recréer un lien remplace le précédent (et remplace aussi un lien créé depuis l'interface Drivecord pour ce même fichier, le cas échéant). DELETE /api/v1/files/:id/public le révoque.

curl -X POST https://ton-domaine.tld/api/v1/files/abc123/public \
  -H "Authorization: Bearer dvc_xxx"

# → { "token": "...", "url": "https://ton-domaine.tld/api/v1/public/..." }

Colle directement l'url renvoyée dans ton site :

<img src="https://ton-domaine.tld/api/v1/public/xxxxxxxxxx" alt="…" />

Supprimer un fichier

curl -X DELETE https://ton-domaine.tld/api/v1/files/abc123 \
  -H "Authorization: Bearer dvc_xxx"

Limites de débit

Chaque clé est limitée à 60 requêtes/minute sur les routes générales, et 300/minute sur /api/v1/files/chunks (une grosse vidéo peut demander beaucoup de petits appels). Les liens publics (/api/v1/public/:token, pas d'authentification) sont limités à 300 requêtes/minute par IP. Au-delà, l'API répond 429 avec un en-tête Retry-After.

Et ensuite