Cas d'usage

Capturer des pages derrière une connexion

Prenez des captures de pages authentifiées — tableaux de bord, portails, rapports, écrans conformité — sans session navigateur manuelle. Automatisez la connexion par commandes et obtenez des captures fiables.

Commencer gratuitement Lire la doc API

Fonctionnement

Automatiser la connexion, puis capturer

La plupart des APIs de capture ne voient que le public. ScreenshotCenter prend en charge les commandes d’automatisation — une séquence d’actions navigateur avant la capture. Vous indiquez la page de connexion, les identifiants, la soumission, l’attente de redirection, puis la page protégée.

L’automatisation tourne dans un vrai Chromium : formulaires JS, routage côté client et chaînes de redirection — comme un utilisateur.

✓Compatible formulaires identifiant / mot de passe
✓Injection de cookies pour sessions
✓Formulaires rendus par JS et SPA
✓Page entière, zone visible ou élément ciblé
✓Sortie PNG, JPEG, WebP, PDF ou vidéo

POST /v1/screenshot

Aller à la page de connexion

{"command": "navigate", "value": "https://app.example.com/login"}

Saisir l’e-mail

{"command": "type", "element": "#email", "value": "user@example.com"}

Saisir le mot de passe

{"command": "type", "element": "#password", "value": "your-password"}

Valider le formulaire

{"command": "click", "element": "#login-button"}

Attendre la redirection

{"command": "sleep", "value": "3"}

Naviguer vers la cible

{"command": "navigate", "value": "https://app.example.com/dashboard"}

Prendre la capture

{"command": "screenshot"}

Exemple en direct

Voir en action

L’automatisation remplit le formulaire, le soumet, attend le tableau de bord puis capture — le tout piloté par le paramètre steps.

Exemple API

Connexion, navigation et capture en une requête

Passez une liste de commandes avec l’URL. Le navigateur exécute chaque étape avant la capture. Utilisez sleep pour les redirections JS et navigate pour la page protégée.

curl -X POST https://api.screenshotcenter.com/v1/screenshot \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://app.example.com/login",
    "steps": [
      {"command": "type",     "element": "#email",        "value": "user@example.com"},
      {"command": "type",     "element": "#password",     "value": "your-password"},
      {"command": "click",    "element": "#login-button"},
      {"command": "sleep",    "value": "3"},
      {"command": "navigate", "value": "https://app.example.com/dashboard"},
      {"command": "sleep",    "value": "2"},
      {"command": "screenshot"}
    ],
    "size": "page",
    "format": "png"
  }'

import { ScreenshotCenterClient } from 'screenshotcenter';

const client = new ScreenshotCenterClient({ apiKey: 'YOUR_API_KEY' });

const screenshot = await client.screenshot.create({
  url: 'https://app.example.com/login',
  steps: [
    { command: 'type',     element: '#email',        value: 'user@example.com' },
    { command: 'type',     element: '#password',     value: 'your-password' },
    { command: 'click',    element: '#login-button' },
    { command: 'sleep',    value: '3' },
    { command: 'navigate', value: 'https://app.example.com/dashboard' },
    { command: 'sleep',    value: '2' },
    { command: 'screenshot' },
  ],
  size: 'page',
});

const result = await client.waitFor(screenshot.id);
await client.screenshot.saveImage(result.id, './dashboard.png');

from screenshotcenter import ScreenshotCenterClient

client = ScreenshotCenterClient(api_key="YOUR_API_KEY")

shot = client.screenshot.create(
    url="https://app.example.com/login",
    steps=[
        {"command": "type",     "element": "#email",        "value": "user@example.com"},
        {"command": "type",     "element": "#password",     "value": "your-password"},
        {"command": "click",    "element": "#login-button"},
        {"command": "sleep",    "value": "3"},
        {"command": "navigate", "value": "https://app.example.com/dashboard"},
        {"command": "sleep",    "value": "2"},
        {"command": "screenshot"},
    ],
    size="page",
)

result = client.wait_for(shot["id"])
client.screenshot.save_image(result["id"], "dashboard.png")

use ScreenshotCenter\Client;

$client = new Client(getenv('SCREENSHOTCENTER_API_KEY'));

$shot = $client->screenshot->create('https://app.example.com/login', [
    'steps' => [
        ['command' => 'type',     'element' => '#email',        'value' => 'user@example.com'],
        ['command' => 'type',     'element' => '#password',     'value' => 'your-password'],
        ['command' => 'click',    'element' => '#login-button'],
        ['command' => 'sleep',    'value' => '3'],
        ['command' => 'navigate', 'value' => 'https://app.example.com/dashboard'],
        ['command' => 'sleep',    'value' => '2'],
        ['command' => 'screenshot'],
    ],
    'size' => 'page',
]);

$result = $client->waitFor($shot['id']);
$client->screenshot->saveImage($result['id'], './dashboard.png');

import sc "github.com/juliensobrier/screenshotcenter-go"

client := sc.New("YOUR_API_KEY")

shot, _ := client.Screenshot.Create("https://app.example.com/login", &sc.CreateParams{
    Steps: []sc.Step{
        {Command: "type",     Element: "#email",        Value: "user@example.com"},
        {Command: "type",     Element: "#password",     Value: "your-password"},
        {Command: "click",    Element: "#login-button"},
        {Command: "sleep",    Value: "3"},
        {Command: "navigate", Value: "https://app.example.com/dashboard"},
        {Command: "sleep",    Value: "2"},
        {Command: "screenshot"},
    },
    Size: "page",
})

result, _ := client.WaitFor(shot.ID, nil)
client.Screenshot.SaveImage(result.ID, "./dashboard.png", nil)

require "screenshotcenter"

client = ScreenshotCenter::Client.new(ENV["SCREENSHOTCENTER_API_KEY"])

shot = client.screenshot.create("https://app.example.com/login",
  steps: [
    { command: "type",     element: "#email",        value: "user@example.com" },
    { command: "type",     element: "#password",     value: "your-password" },
    { command: "click",    element: "#login-button" },
    { command: "sleep",    value: "3" },
    { command: "navigate", value: "https://app.example.com/dashboard" },
    { command: "sleep",    value: "2" },
    { command: "screenshot" },
  ],
  size: "page"
)

result = client.wait_for(shot["id"])
client.screenshot.save_image(result["id"], "./dashboard.png")

import io.screenshotcenter.ScreenshotCenterClient;
import io.screenshotcenter.models.*;
import java.util.List;

public class Main {
    public static void main(String[] args) throws Exception {
        var client = new ScreenshotCenterClient("YOUR_API_KEY");

        var params = new ScreenshotParams()
            .url("https://app.example.com/login")
            .steps(List.of(
                new Step("type",     "#email",        "user@example.com"),
                new Step("type",     "#password",     "your-password"),
                new Step("click",    "#login-button", null),
                new Step("sleep",    null,            "3"),
                new Step("navigate", null,            "https://app.example.com/dashboard"),
                new Step("sleep",    null,            "2"),
                new Step("screenshot")
            ))
            .size("page");

        var shot   = client.screenshot().create(params);
        var result = client.waitFor(shot.getId());
        client.screenshot().saveImage(result.getId(), "./dashboard.png");
    }
}

using ScreenshotCenter;

var client = new ScreenshotCenterClient("YOUR_API_KEY");

var shot = await client.Screenshot.CreateAsync(new ScreenshotParams {
    Url = "https://app.example.com/login",
    Steps = new[] {
        new Step { Command = "type",     Element = "#email",        Value = "user@example.com" },
        new Step { Command = "type",     Element = "#password",     Value = "your-password" },
        new Step { Command = "click",    Element = "#login-button" },
        new Step { Command = "sleep",    Value = "3" },
        new Step { Command = "navigate", Value = "https://app.example.com/dashboard" },
        new Step { Command = "sleep",    Value = "2" },
        new Step { Command = "screenshot" },
    },
    Size = "page",
});

var result = await client.WaitForAsync(shot.Id);
await client.Screenshot.SaveImageAsync(result.Id, "./dashboard.png");

Pour éviter le formulaire : utilisez le paramètre cookies pour injecter un cookie de session existant.

Alternative : injecter des cookies de session

Avec un jeton de session valide, sautez la connexion en injectant les cookies : plus rapide, moins de CAPTCHA, adapté au SSO/OAuth.

curl -X POST https://api.screenshotcenter.com/v1/screenshot \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://app.example.com/dashboard",
    "cookies": [
      {
        "name": "session_token",
        "value": "eyJhbGciOiJIUzI1...",
        "domain": "app.example.com"
      }
    ],
    "size": "page"
  }'

const screenshot = await client.screenshot.create({
  url: 'https://app.example.com/dashboard',
  cookies: [{ name: 'session_token', value: 'eyJhbGciOiJIUzI1...', domain: 'app.example.com' }],
  size: 'page',
});
const result = await client.waitFor(screenshot.id);
await client.screenshot.saveImage(result.id, './dashboard.png');

shot = client.screenshot.create(
    url="https://app.example.com/dashboard",
    cookies=[{"name": "session_token", "value": "eyJhbGciOiJIUzI1...", "domain": "app.example.com"}],
    size="page",
)
result = client.wait_for(shot["id"])
client.screenshot.save_image(result["id"], "dashboard.png")

$shot = $client->screenshot->create('https://app.example.com/dashboard', [
    'cookies' => [['name' => 'session_token', 'value' => 'eyJhbGciOiJIUzI1...', 'domain' => 'app.example.com']],
    'size'    => 'page',
]);
$result = $client->waitFor($shot['id']);
$client->screenshot->saveImage($result['id'], './dashboard.png');

shot, _ := client.Screenshot.Create("https://app.example.com/dashboard", &sc.CreateParams{
    Cookies: []sc.Cookie{{Name: "session_token", Value: "eyJhbGciOiJIUzI1...", Domain: "app.example.com"}},
    Size: "page",
})
result, _ := client.WaitFor(shot.ID, nil)
client.Screenshot.SaveImage(result.ID, "./dashboard.png", nil)

shot = client.screenshot.create("https://app.example.com/dashboard",
  cookies: [{ name: "session_token", value: "eyJhbGciOiJIUzI1...", domain: "app.example.com" }],
  size: "page"
)
result = client.wait_for(shot["id"])
client.screenshot.save_image(result["id"], "./dashboard.png")

var params = new ScreenshotParams()
    .url("https://app.example.com/dashboard")
    .cookies(List.of(
        new Cookie("session_token", "eyJhbGciOiJIUzI1...", "app.example.com")
    ))
    .size("page");

var shot   = client.screenshot().create(params);
var result = client.waitFor(shot.getId());
client.screenshot().saveImage(result.getId(), "./dashboard.png");

var shot = await client.Screenshot.CreateAsync(new ScreenshotParams {
    Url = "https://app.example.com/dashboard",
    Cookies = new[] {
        new Cookie { Name = "session_token", Value = "eyJhbGciOiJIUzI1...", Domain = "app.example.com" }
    },
    Size = "page",
});
var result = await client.WaitForAsync(shot.Id);
await client.Screenshot.SaveImageAsync(result.Id, "./dashboard.png");

Cas d'usage

Ce que les équipes automatisent avec des captures authentifiées

La capture authentifiée ouvre conformité, veille tableau de bord et bien plus — impossible avec une API réservée au public.

📊

Veille tableaux de bord SaaS

Capturez automatiquement les tableaux connectés — graphiques, métriques, tuiles KPI — sans vous reconnecter. Envoyez des instantanés quotidiens vers Slack ou Google Drive.

→Tableaux analytiques (Mixpanel, Amplitude, outils internes)
→Résumés facturation et statut d’abonnement
→Consoles admin et panneaux de supervision

📋

Portails clients et facturation

Capturez factures, relevés et rapports clients en PDF ou image. Automatisez les dossiers mensuels sans session navigateur manuelle.

→PDF de facturation depuis les portails
→Instantanés portail pour chefs de compte
→Rapports PDF automatisés depuis les back-offices SaaS

🛡️

Conformité et audits

Captures horodatées de pages réglementées authentifiées — consentements, politiques, journaux d’audit — pour la documentation juridique.

→Tableaux de bord de gestion du consentement RGPD
→Captures de journaux pour preuves SOC 2
→Écrans de confirmation d’acceptation des politiques

🧪

CI / QA sur routes protégées

Contrôles automatisés en CI sur routes protégées — profils, paramètres, tunnel d’achat — pour détecter les régressions visuelles avant la prod.

→Pages profil et paramètres compte
→Tunnel d’achat et confirmation de paiement
→Contenu sous feature flag visible seulement connecté

🔍

Contenu personnalisé par utilisateur

Pages qui changent selon l’utilisateur — accueil, recommandations, tarifs — pour valider la logique de segmentation.

→Variantes A/B visibles après connexion
→Recommandations produits personnalisées
→Fonctions selon le niveau de compte

📡

Documentation outils internes

Documentez CRM, ERP et admin par captures planifiées. Construisez des journaux visuels pour les équipes internes.

→Captures hebdo des vues CRM pour les ops
→Instantanés admin avant/après déploiement
→Changelogs visuels automatisés pour les releases internes

Automation Commands

All commands available in automation steps

Combine any number of these commands to replicate the exact browser interactions your login flow requires.

Commande	Description	Exemple de valeur
type	Type text into a form field	"value": "user@example.com", "element": "#email"
click	Click a button or link	"element": "#submit-btn"
navigate	Navigate to a new URL	"value": "https://app.example.com/dashboard"
sleep	Wait a number of seconds	"value": "3"
javascript	Execute any JavaScript	"value": "document.querySelector('#modal').remove()"
screenshot	Take screenshot at this point	(no value needed)

Bonnes pratiques sécurité

Gérer les identifiants avec prudence

Comptes de service

Créez un compte dédié en lecture seule pour l’automatisation. N’utilisez jamais des identifiants personnels dans les requêtes API.

Injection de cookies

Préférez les cookies à la saisie formulaire quand la plateforme le permet : moins d’exposition des identifiants dans la charge utile.

Variables d’environnement

Ne codez jamais en dur. Passez les secrets via variables d’environnement en CI/CD ou côté serveur.

Rotation régulière

Faites tourner mots de passe et jetons et révoquez ceux qui ne servent plus.

Commencer à capturer des pages authentifiées

500 captures gratuites pour tester votre flux de connexion. Sans carte bancaire. Étapes complètes, cookies et formats multiples dès le départ.

Créer un compte gratuit Lire la doc API Parcourir tous les cas d'usage

Questions fréquentes

Est-il sûr d’envoyer des identifiants à l’API ?

Transit HTTPS uniquement pendant la session de capture ; rien n’est stocké ni journalisé après le job. Privilégiez des comptes de service en lecture seule plutôt que des comptes personnels.

Et OAuth ou SSO ?

Oui : Commandes pour suivre OAuth, saisir sur le fournisseur d’identité, gérer les redirections. L’injection de cookies fonctionne aussi pour le SSO par session.

Et si la page a un CAPTCHA ?

Sur votre plateforme, désactivez souvent le CAPTCHA pour IP de confiance ou agent automatisé. Sinon, injectez un cookie de session existant pour éviter le formulaire.

Réutiliser une session sur plusieurs captures ?

Oui : une fois les cookies obtenus, injectez-les avec le paramètre cookies et sautez les commandes de connexion pour aller plus vite.

Et l’A deux facteurs (MFA) ?

TOTP/SMS est difficile à automatiser. Recommandé : compte de service sans MFA, cookies d’une session déjà authentifiée, ou jetons API si disponibles.

Capturer un élément précis sur la page authentifiée ?

Oui : après connexion, utilisez target avec un sélecteur CSS pour cibler un graphique, un tableau, etc., plutôt que la page entière.

Par langage

SDK Python SDK JavaScript SDK Java SDK PHP SDK Go SDK C# / .NET SDK Ruby