Documentation API

L'API Wasate Cloud permet d'intégrer notre plateforme à vos outils. REST classique, JSON, authentification simple par clé API.

Introduction

L'API Wasate Cloud expose les fonctionnalités suivantes :

• Inscription et activation de comptes via le workflow PIN à deux facteurs
• Transferts WeTransfer-like : création, listing, gestion
• Galeries clients : création, tokens de partage, viewer public (4 thèmes + lightbox), notifications email de consultation/téléchargement
• Bureau portable (Wasate Connect) : enrôlement d'appareils multi-OS, synchronisation, révocation
• Connexion « Continuer avec Google » (sign-in OAuth/OIDC, scopes basiques) + import depuis un autre cloud (Dropbox, OneDrive)
• Compte : préférences de notification, abonnement Solo Pro/Solo Max (paiement Stripe)
• API Distributeur : gestion programmatique des clients apportés (création, quota, statistiques), authentifiée par clé API
• Webhooks entrants (paiements bancaires)

Base URL : https://wasate.fr

Table de référence rapide

Vous cherchez « comment on fait X » ? Cette table couvre les besoins les plus fréquents, avec le vrai chemin d'API — et indique honnêtement ce qui n'existe pas encore, pour éviter de chercher un endpoint qui n'a jamais été construit.

Authentification

Trois mécanismes d'authentification selon le type d'endpoint :

1. Session utilisateur (cookies)

Pour les endpoints utilisés depuis le frontend web. Connexion via /app/login, cookie de session HttpOnly + Secure.

2. Clé API (header)

Pour les intégrations serveur-à-serveur. Deux types de clés, même format et même en-tête :

• Clé personnelle — tous les comptes, onglet « API » de votre espace (au-dessus de « Signature électronique »). Cliquez « Générer » : la clé vous est envoyée par email, jamais affichée à l'écran. Donne accès en lecture seule à vos propres données : profil (/api/me), fichiers, corbeille, sessions, galeries, transferts, signatures et RGPD — voir détail complet. Toute action qui modifie un état (créer, modifier, supprimer, suppression de compte, révocation de sessions, changements de consentement) reste réservée à la session cookie — protection CSRF du site oblige, une clé ne peut par nature pas la satisfaire sans l'affaiblir pour tout le monde.
• Clé distributeur — réservée aux comptes distributeur, section « Clés API » de l'espace distributeur, même principe (email uniquement). Donne accès à tout l'API Distributeur (/api/v1/distributor/*).

curl -H "Authorization: Bearer wsd_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" \
     https://wasate.fr/api/me

Format de la clé : wsd_live_ (ou wsd_test_ pour une clé de test) suivi d'un secret aléatoire de 32 caractères. La clé n'est jamais affichée dans l'interface — elle arrive par email à la création, et seul un préfixe tronqué reste visible ensuite pour l'identifier (pas pour vous la re-fournir).

3. Webhook HMAC

Pour les webhooks entrants, signature HMAC-SHA256 du body avec le secret configuré.

Démarrage rapide — script complet

Connexion par identifiant/mot de passe, puis appel authentifié à /api/me. Le cookie de session gère l'authentification ; le requesttoken (CSRF) est nécessaire pour toute requête qui modifie un état (POST/PUT/DELETE).

import requests

BASE = "https://wasate.fr"
session = requests.Session()

# 1) Connexion (endpoint natif de la plateforme)
login = session.post(f"{BASE}/app/login", data={
    "user": "mon-identifiant",
    "password": "mon-mot-de-passe",
    "requesttoken": "",  # premier appel : la plateforme accepte un requesttoken vide au login
})
login.raise_for_status()

# 2) Récupérer un requesttoken CSRF valide pour les appels suivants
csrf_page = session.get(f"{BASE}/app/csrftoken")
csrf_token = csrf_page.json()["token"]

# 3) Appel authentifié
me = session.get(f"{BASE}/api/me", headers={"requesttoken": csrf_token})
print(me.json())

const BASE = "https://wasate.fr";

// Dans le contexte du frontend web (déjà connecté), csrfToken est déjà
// disponible en variable globale. Exemple depuis un script externe :
const csrfRes = await fetch(`${BASE}/app/csrftoken`, { credentials: "include" });
const { token: csrfToken } = await csrfRes.json();

const me = await fetch(`${BASE}/api/me`, {
  credentials: "include",
  headers: { "requesttoken": csrfToken, "Accept": "application/json" },
});
console.log(await me.json());

# 1) Connexion (garde le cookie dans un fichier)
curl -c cookies.txt -X POST https://wasate.fr/app/login \
     -d "user=mon-identifiant" -d "password=mon-mot-de-passe"

# 2) Appel authentifié (réutilise le cookie de session)
curl -b cookies.txt https://wasate.fr/api/me

Gestion des erreurs

Toutes les erreurs retournent un JSON avec un champ error contenant un code court :

{
  "error": "invalid_email"
}

Codes HTTP utilisés :

• 400 — Bad Request (champ invalide, format incorrect)
• 401 — Unauthorized (clé API absente ou invalide)
• 403 — Forbidden (rôle insuffisant)
• 404 — Not Found
• 409 — Conflict (email déjà utilisé, demande en cours, etc.)
• 429 — Too Many Requests (rate limit)
• 500 — Internal Server Error

Rate limits

/api/account/request (et l'inscription en général) n'est pas limité par un compteur fixe de requêtes/minute : une IP qui enchaîne les échecs (formulaire refusé, captcha invalide, etc.) est bloquée automatiquement après plusieurs tentatives infructueuses sur une fenêtre glissante de 15 minutes, indépendamment du nombre de requêtes réussies.

• Endpoints authentifiés via clé API : selon le rate_limit défini sur la clé (60 requêtes/minute par défaut)

Endpoints publics

{
  "email": "client@example.com",
  "name": "Marie Dupont",
  "subject": "general",
  "message": "Bonjour, j'aimerais en savoir plus sur..."
}

{
  "status": "ok",
  "service": "wasate-cloud",
  "time": "2026-05-22T14:30:00+00:00"
}

{ "email": "contact@example.com" }

{
  "first_name": "Marie",
  "last_name": "Dupont",
  "email": "marie@example.com",
  "phone": "+33 6 12 34 56 78",
  "account_type": "client_pro",
  "plan": "solo_pro",
  "captcha_token": "..."
}

Webhook : paiement reçu

Endpoint exposé par Wasate Cloud, appelé par votre passerelle bancaire ou Zapier après réception d'un virement SEPA.

{
  "reference": "WAS-MARIEDUPONT",
  "amount": 8.00,
  "currency": "EUR",
  "date": "2026-05-22T10:00:00Z"
}

Signature HMAC

Pour les webhooks entrants, la signature est calculée ainsi :

// Node.js
const crypto = require('crypto');
const signature = crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(rawBody)
    .digest('hex');

// Envoyer dans header X-Wasate-Signature

Bureau portable (Wasate Connect)

Important, pour rester honnête : il n'existe aujourd'hui aucune application de bureau Wasate Connect prête à l'emploi à télécharger et installer. Ce qui suit est le contrat d'API réel côté serveur (fonctionnel, testé) — mais côté appareil, connecter une machine suppose de faire tourner votre propre instance Syncthing et d'orchestrer les deux appels ci-dessous vous-même. Ce n'est donc pas « juste un token d'API » : c'est un enrôlement en deux étapes, décrit précisément ci-dessous pour éviter toute ambiguïté.

Vue d'ensemble du flux

1. Depuis votre session Wasate (compte déjà connecté, cookie de session — pas de clé API) : POST /api/workspace/devices génère un code à usage unique, valable 1 h.
2. Sur l'appareil à connecter : démarrez une instance Syncthing locale (syncthing serve) et récupérez son identifiant unique via son API REST locale (GET http://127.0.0.1:8384/rest/system/status → champ myID).
3. Toujours sur l'appareil : échangez le code + cet identifiant Syncthing contre des identifiants de synchronisation via POST /connect/enroll (public, pas de cookie — c'est l'appareil qui appelle directement, pas votre navigateur).
4. Avec la réponse reçue, configurez votre Syncthing local pour partager le dossier avec le serveur Wasate (folder_id/server_device_id/server_addresses reçus) — c'est Syncthing, pas Wasate, qui gère ensuite le transfert de fichiers lui-même.
5. L'appareil appelle périodiquement POST /connect/heartbeat pour rester listé comme actif.

Le mot de passe principal du compte n'est jamais transmis à aucune étape. Le agent_token reçu à l'enrôlement n'est utilisé que pour le heartbeat/la déconnexion — pas pour le transfert de fichiers, qui passe entièrement par le protocole natif de Syncthing une fois les deux instances appairées.

{
  "code": "xxxxx",
  "device_name": "PC bureau",
  "os": "linux",
  "syncthing_device_id": "<myID renvoyé par l'API REST locale de VOTRE Syncthing>"
}

{
  "server_url": "https://wasate.cloud/app",
  "device_id": 12,
  "device_name": "PC bureau",
  "agent_token": "<jeton de maintenance — heartbeat/disconnect uniquement>",
  "sync_folder": "Wasate",
  "syncthing": {
    "folder_id": "wsp-xxxxxxxxxxxxxxxx",
    "server_device_id": "<identifiant Syncthing du serveur Wasate, à ajouter comme appareil connu dans VOTRE Syncthing>",
    "server_addresses": ["tcp://wasate.cloud:22000"]
  }
}

{ "password": "<agent_token reçu à l'enrôlement>" }

{ "password": "<agent_token reçu à l'enrôlement>" }

{ "name": "PC bureau", "os": "linux" }  →  { "code": "xxxxx", "expires_in": 3600 }

Galeries, transferts, signatures, RGPD (mon compte)

Ces endpoints gèrent VOS ressources (session requise). Chaque appel n'agit que sur les ressources de l'utilisateur authentifié.

Galeries

{
  "title": "Mariage Julie & Tom",
  "description": "…",
  "source_path": "/Photos/Mariage",
  "theme": "minimal",
  "is_public": false
}

{
  "token_id": 12,
  "token": "a3f9…",
  "expires_at": "2026-08-01T00:00:00+00:00",
  "url": "/galerie.html?t=a3f9…"
}

Script complet — créer et partager une galerie

import requests

BASE = "https://wasate.fr"
session = requests.Session()
session.post(f"{BASE}/app/login", data={
    "user": "mon-identifiant", "password": "mon-mot-de-passe", "requesttoken": "",
}).raise_for_status()
csrf_token = session.get(f"{BASE}/app/csrftoken").json()["token"]
headers = {"requesttoken": csrf_token}

# 1) Créer la galerie à partir d'un dossier déjà présent dans mon espace
r = session.post(f"{BASE}/api/galleries", headers=headers, json={
    "title": "Mariage Julie & Tom",
    "description": "Séance photo du 12 juillet",
    "source_path": "/Photos/Mariage-JulieTom",
    "theme": "minimal",
})
r.raise_for_status()
gallery = r.json()
print("Galerie créée, id =", gallery["id"])

# 2) Générer un lien de partage public, valable 7 jours, sans mot de passe
share = session.post(f"{BASE}/api/galleries/{gallery['id']}/share", headers=headers,
                      json={"ttl": 604800}).json()
print("Lien à envoyer au client :", BASE + share["url"])

const BASE = "https://wasate.fr";
// Depuis le frontend web (session + csrfToken déjà disponibles) :

const galleryRes = await fetch(`${BASE}/api/galleries`, {
  method: "POST", credentials: "include",
  headers: { "Content-Type": "application/json", "requesttoken": csrfToken },
  body: JSON.stringify({
    title: "Mariage Julie & Tom",
    description: "Séance photo du 12 juillet",
    source_path: "/Photos/Mariage-JulieTom",
    theme: "minimal",
  }),
});
const gallery = await galleryRes.json();
console.log("Galerie créée, id =", gallery.id);

const shareRes = await fetch(`${BASE}/api/galleries/${gallery.id}/share`, {
  method: "POST", credentials: "include",
  headers: { "Content-Type": "application/json", "requesttoken": csrfToken },
  body: JSON.stringify({ ttl: 604800 }),
});
const share = await shareRes.json();
console.log("Lien à envoyer au client :", BASE + share.url);

Transferts

{
  "name": "Rushs tournage",
  "ttl": 604800,
  "password": null,
  "max_downloads": 0,
  "recipient_email": "client@example.com"
}

Signatures électroniques

RGPD

Corbeille

Galeries publiques (viewer)

Endpoints publics qui servent une galerie partagée via son token (lien /galerie.html?t={token}, 4 thèmes + lightbox). Galerie protégée par mot de passe → l'envoyer une fois sur /auth pour obtenir un grant à rejouer sur les autres appels.

Compte (utilisateur connecté)

API Distributeur

Réservée aux comptes distributeur : gestion programmatique de vos clients apportés (création, quota, statistiques), en plus de votre espace distributeur habituel.

Gérer vos clés API (session requise)

Depuis votre espace distributeur (section « Clés API »), ou directement :

{ "label": "Intégration CRM", "expires_in_days": 365, "test": false }

{
  "status": "created",
  "key": "wsd_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "prefix": "wsd_live_xxx",
  "id": 4,
  "warning": "Copiez cette clé maintenant — elle ne sera plus jamais affichée."
}

Utiliser l'API (clé API requise, header Authorization: Bearer wsd_live_…)

Base : https://wasate.fr/api/v1/distributor. Chaque appel n'agit que sur vos propres clients (ceux créés via votre clé ou inscrits avec un de vos codes affiliés) — toute tentative sur un client qui ne vous appartient pas renvoie 403 not_your_client.

{
  "uid": "identifiant-unique",
  "email": "client@example.com",
  "display_name": "Marie Dupont",
  "plan": "solo_pro",
  "quota_gb": 200,
  "send_email": true
}

Script complet — provisionner un client

import requests

BASE = "https://wasate.fr/api/v1/distributor"
HEADERS = {"Authorization": "Bearer wsd_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}

# 1) Créer le client
r = requests.post(f"{BASE}/clients", headers=HEADERS, json={
    "uid": "studio-dupont",
    "email": "contact@studio-dupont.fr",
    "display_name": "Studio Dupont",
    "plan": "solo_pro",
    "quota_gb": 300,
    "send_email": True,
})
r.raise_for_status()
client = r.json()
print("Client créé :", client["uid"], "— email envoyé :", client["email_sent"])

# 2) Vérifier ses statistiques d'usage
stats = requests.get(f"{BASE}/clients/{client['uid']}/stats", headers=HEADERS).json()
print(stats)

# 3) Ajuster son quota plus tard si besoin
requests.post(f"{BASE}/clients/{client['uid']}/quota", headers=HEADERS,
              json={"quota_gb": 500})

const BASE = "https://wasate.fr/api/v1/distributor";
const HEADERS = { "Authorization": "Bearer wsd_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" };

// 1) Créer le client
const createRes = await fetch(`${BASE}/clients`, {
  method: "POST",
  headers: { ...HEADERS, "Content-Type": "application/json" },
  body: JSON.stringify({
    uid: "studio-dupont",
    email: "contact@studio-dupont.fr",
    display_name: "Studio Dupont",
    plan: "solo_pro",
    quota_gb: 300,
    send_email: true,
  }),
});
const client = await createRes.json();
console.log("Client créé :", client.uid, "— email envoyé :", client.email_sent);

// 2) Statistiques d'usage
const stats = await (await fetch(`${BASE}/clients/${client.uid}/stats`, { headers: HEADERS })).json();
console.log(stats);

// 3) Ajuster le quota
await fetch(`${BASE}/clients/${client.uid}/quota`, {
  method: "POST",
  headers: { ...HEADERS, "Content-Type": "application/json" },
  body: JSON.stringify({ quota_gb: 500 }),
});

Connexion avec Google + intégrations

Sign-in OAuth/OIDC via Google, scopes basiques openid email profile (aucun accès aux fichiers, aucun audit). Bouton « Continuer avec Google » sur connexion et inscription. L'id_token est vérifié (signature RS256, claims) et email_verified est exigé avant création/activation du compte.

Spec OpenAPI

Une spécification OpenAPI 3.1 complète est disponible : /docs/openapi.yaml (à venir).

SDKs

Aucun SDK officiel n'est encore distribué. L'API étant REST classique, tous les clients HTTP fonctionnent (curl, fetch, axios, requests, Guzzle, …).

Changelog

• v1.3 — Juillet 2026 : API Distributeur complète (/api/v1/distributor/*, gestion de clients + quota + stats), gestion des clés API distributeur, identifiants d'application WebDAV (/api/me/token)
• v1.2 — Juin 2026 : viewer galeries publiques (thèmes + lightbox), notifications email, demande d'upgrade par To, connexion « Continuer avec Auth0 » + import OAuth (Dropbox/OneDrive)
• v1.1 — Juin 2026 : agent Bureau portable (Wasate Connect) — endpoints /connect/* et /api/workspace
• v1.0 — Mai 2026 : version initiale, endpoints contact + inscription + webhook paiement