PromptShieldpromptShieldpromptShield
FonctionsFonctionnementConfidentialitéTarifsTéléchargerDéveloppeurs
FAQSignaler un bugForum communautaireChatbot IA
ConnexionEssai gratuit
Developers
Référence API

Documentation API

Référence complète de l'API REST pour le moteur PromptShield auto-hébergé. Tous les endpoints sont disponibles à l'URL de votre déploiement.

URL de base

http://localhost:8000

Remplacez par l'hôte et le port de votre déploiement.

Documentation API interactive

Lorsque le serveur est en cours d'exécution, visitez /docs pour une interface Swagger interactive auto-générée où vous pouvez tester chaque endpoint directement.

http://localhost:8000/docs

Authentification

L'API auto-hébergée fonctionne sur votre infrastructure. L'authentification est optionnelle et configurable via des variables d'environnement. Par défaut, l'API accepte toutes les requêtes locales.

Démarrage rapide

Lancez l'API locale en moins de 5 minutes.

1

Installer le package

bash
pip install promptshield-app
2

Télécharger un modèle de langue

bash
python -m spacy download en_core_web_sm
3

Configurer votre clé API

bash
export PROMPTSHIELD_API_KEY="ps_live_your_key_here"

Votre clé API est disponible dans le tableau de bord des clés API.

4

Démarrer le serveur

bash
promptshield serve --port 8000
5

Traiter votre premier document

bash
curl -X POST http://localhost:8000/api/documents/upload \
  -F "file=@contract.pdf"
# → {"id": "abc123", "filename": "contract.pdf", "pages": 5}

curl -X POST http://localhost:8000/api/documents/abc123/detect
# → {"status": "completed", "regions_count": 42}

curl -X POST http://localhost:8000/api/documents/abc123/anonymize
# → {"status": "completed", "tokens_created": 42}

curl -o contract-safe.pdf \
  http://localhost:8000/api/documents/abc123/download/pdf

Ou lancez avec Docker (aucune installation)

bash
docker run -e PROMPTSHIELD_API_KEY="ps_live_your_key_here" \
  -p 8000:8000 -v promptshield-data:/data \
  promptshield/promptshield-api:latest

Guide étape par étape

Un guide complet pour configurer l'API locale et l'intégrer dans votre flux de travail.

1. Prérequis

Avant de commencer, assurez-vous d'avoir installé :

Python 3.11 ou plus récent
pip (inclus avec Python)
Une clé API PromptShield (plan Professionnel ou Business)

Optionnel — pour le support complet des formats :

Tesseract OCR — pour les PDF scannés/images
LibreOffice — pour la conversion .docx, .xlsx, .pptx

2. Installer le SDK

Installez le package Python PromptShield. L'installation de base gère les fichiers PDF. Ajoutez l'extra office pour Word/Excel/PowerPoint.

Installation de base (PDF uniquement)
bash
pip install promptshield-app
Avec support des formats Office
bash
pip install "promptshield-app[office]"

Téléchargez au moins un modèle NLP spaCy :

bash
# English (required — at least one model)
python -m spacy download en_core_web_sm

# For better accuracy (larger model)
python -m spacy download en_core_web_lg

Pour d'autres langues, ajoutez le modèle correspondant :

bash
python -m spacy download fr_core_news_sm   # French
python -m spacy download de_core_news_sm   # German
python -m spacy download es_core_news_sm   # Spanish
python -m spacy download it_core_news_sm   # Italian
python -m spacy download nl_core_news_sm   # Dutch
python -m spacy download pt_core_news_sm   # Portuguese

3. Authentification

L'API locale utilise votre clé API PromptShield pour la validation de licence. Définissez-la comme variable d'environnement ou passez-la au démarrage du serveur.

macOS / Linux
bash
export PROMPTSHIELD_API_KEY="ps_live_your_key_here"
Windows (PowerShell)
bash
$env:PROMPTSHIELD_API_KEY = "ps_live_your_key_here"

La clé API est validée en ligne au démarrage puis mise en cache localement pendant 35 jours, permettant au serveur de fonctionner entièrement hors ligne après le premier lancement.

4. Démarrer le serveur API

Lancez le serveur local avec une seule commande :

bash
promptshield serve
# Starting PromptShield API server on 127.0.0.1:8000
# API docs available at http://127.0.0.1:8000/docs

Options disponibles :

--hostAdresse de liaison (défaut : 127.0.0.1)
--portPort de liaison (défaut : 8000)
--api-keyClé API (alternative à la variable d'environnement)

Une fois démarré, l'API est accessible à l'URL affichée. La documentation Swagger interactive est à /docs.

5. Déploiement Docker (Alternative)

Pour les déploiements en production, Docker offre une expérience sans installation avec toutes les dépendances incluses.

Conteneur unique
bash
docker run -d --name promptshield \
  -e PROMPTSHIELD_API_KEY="ps_live_your_key_here" \
  -p 8000:8000 \
  -v promptshield-data:/data \
  promptshield/promptshield-api:latest
Avec Docker Compose
bash
# docker-compose.yml
services:
  promptshield:
    image: promptshield/promptshield-api:latest
    ports:
      - "8000:8000"
    volumes:
      - promptshield-data:/data
    environment:
      - PROMPTSHIELD_API_KEY=${PROMPTSHIELD_API_KEY}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/health"]
      interval: 30s

volumes:
  promptshield-data:

Créez un fichier .env avec votre clé API :

.env
bash
PROMPTSHIELD_API_KEY=ps_live_your_key_here

L'image Docker inclut :

Tesseract OCR avec 7 packs de langues (EN, FR, DE, ES, IT, NL, PT)
LibreOffice pour la conversion des formats Office
Modèles NLP spaCy pré-installés
Utilisateur non-root, vérifications de santé, volume de données persistant

6. Flux de travail API

Le flux de traitement standard comprend 5 étapes :

1Upload — Envoyez votre document au serveur
2Détection — Lancez le pipeline de détection (regex + NER + LLM optionnel)
3Révision — Inspectez les régions détectées, modifiez ou confirmez
4Anonymisation — Remplacez les DCP par des codes
5Téléchargement — Récupérez le document anonymisé

Exemple complet du flux (cURL)

cURL
bash
# 1. Upload
DOC_ID=$(curl -s -X POST http://localhost:8000/api/documents/upload \
  -F "file=@contract.pdf" | python -c "import sys,json; print(json.load(sys.stdin)['id'])")

echo "Document ID: $DOC_ID"

# 2. Detect PII
curl -X POST http://localhost:8000/api/documents/$DOC_ID/detect
# → {"status": "completed", "regions_count": 42}

# 3. Review detected regions
curl http://localhost:8000/api/documents/$DOC_ID/regions | python -m json.tool
# → [{"type": "PERSON", "text": "John Smith", "score": 0.98}, ...]

# 4. Anonymize
curl -X POST http://localhost:8000/api/documents/$DOC_ID/anonymize
# → {"status": "completed", "tokens_created": 42}

# 5. Download the anonymized document
curl -o contract-safe.pdf \
  http://localhost:8000/api/documents/$DOC_ID/download/pdf

echo "Done! Anonymized file saved to contract-safe.pdf"

7. Commandes CLI

Traitez des documents directement depuis la ligne de commande sans démarrer de serveur :

Détecter les DCP et sauvegarder un rapport JSON
bash
promptshield detect invoice.pdf
# Detected 23 PII entities across 5 pages

promptshield detect invoice.pdf -o report.json
# Report saved to report.json
Anonymiser un document en une étape
bash
promptshield anonymize contract.pdf -o contract-safe.pdf
# Anonymized: 42 tokens created, saved to contract-safe.pdf
Restaurer les codes dans un document anonymisé
bash
promptshield detokenize contract-safe.pdf -o contract-restored.pdf
# Restored 42 tokens, saved to contract-restored.pdf

Toutes les commandes CLI valident votre clé API et traitent les documents localement. Aucune donnée ne quitte votre machine.

8. SDK Python (Import direct)

Pour les intégrations avancées, importez les modules core directement dans votre code Python. Cela vous donne le contrôle total sur chaque étape du traitement.

Exemple Python complet
bash
import asyncio
from pathlib import Path
from promptshield import ingest_document, detect_pii_on_page, anonymize_document

async def process(input_path: str, output_path: str):
    # Step 1 — Ingest document
    doc = await ingest_document(input_path, Path(input_path).name)
    print(f"Loaded: {doc.filename} ({len(doc.pages)} pages)")

    # Step 2 — Detect PII
    total_entities = 0
    for page in doc.pages:
        regions = detect_pii_on_page(page)
        total_entities += len(regions)
        print(f"  Page {page.number}: {len(regions)} entities found")

    print(f"Total PII entities: {total_entities}")

    # Step 3 — Anonymize
    result = await anonymize_document(doc)
    print(f"Anonymized: {result.tokens_created} tokens created")

    # Save the result
    with open(output_path, "wb") as f:
        f.write(result.content)
    print(f"Saved to {output_path}")

asyncio.run(process("contract.pdf", "contract-safe.pdf"))

Exemple de traitement par lots

Traiter plusieurs fichiers dans un répertoire :

batch_process.py
bash
import asyncio
from pathlib import Path
from promptshield import ingest_document, detect_pii_on_page, anonymize_document

async def batch_process(input_dir: str, output_dir: str):
    input_path = Path(input_dir)
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)

    files = list(input_path.glob("*.pdf"))
    print(f"Processing {len(files)} files...")

    for i, file in enumerate(files, 1):
        print(f"[{i}/{len(files)}] {file.name}")
        doc = await ingest_document(str(file), file.name)

        for page in doc.pages:
            detect_pii_on_page(page)

        result = await anonymize_document(doc)

        out_file = output_path / f"anon_{file.name}"
        with open(out_file, "wb") as f:
            f.write(result.content)

        print(f"  → {result.tokens_created} tokens, saved to {out_file.name}")

    print("Batch complete!")

asyncio.run(batch_process("./documents", "./anonymized"))

9. Sécurité & Confidentialité

PromptShield est conçu pour les environnements zero-trust :

Tout le traitement se fait localement — aucun contenu de document n'est envoyé à des serveurs externes
Le coffre de codes est chiffré au repos (AES-256-GCM)
L'authentification par clé API empêche les accès non autorisés en mode auto-hébergé
Docker fonctionne en tant qu'utilisateur non-root avec des privilèges minimaux
Clé API validée en ligne une fois, puis mise en cache localement pour usage hors ligne (TTL de 35 jours)

10. Dépannage

Problèmes courants et solutions :

Erreur 'No spaCy model found'

Installez au moins un modèle : python -m spacy download en_core_web_sm

L'OCR ne fonctionne pas sur les PDF scannés

Installez Tesseract OCR et assurez-vous qu'il est dans votre PATH. Sur Windows, l'installateur l'ajoute automatiquement.

Échec de conversion des fichiers Office

Installez LibreOffice. DOCX a un fallback Python pur, mais XLSX/PPTX nécessitent LibreOffice.

'Invalid API key' au démarrage

Vérifiez que votre clé commence par ps_live_ et que votre abonnement est actif. Les clés sont gérables à /developers/api-keys.

Documents

POST
/api/documents/upload

Uploader un document

Uploadez un document pour traitement. Supporte les fichiers PDF, DOCX, XLSX, PPTX et images.

GET
/api/documents

Lister les documents

Récupérez tous les documents uploadés avec leur statut de détection et d'anonymisation.

GET
/api/documents/{id}

Obtenir un document

Obtenez les informations détaillées d'un document spécifique, y compris le nombre de pages et le statut de détection.

DELETE
/api/documents/{id}

Supprimer un document

Supprimez un document et toutes les données associées du serveur.

Détection

POST
/api/documents/{id}/detect

Détecter les DCP

Exécutez le pipeline de détection de DCP sur un document. Combine regex, NER et couches LLM optionnelles.

GET
/api/documents/{id}/regions

Obtenir les régions

Récupérez toutes les régions de DCP détectées pour un document avec type, texte, score de confiance et boîte englobante.

Anonymisation & Export

POST
/api/documents/{id}/anonymize

Anonymiser un document

Anonymisez un document en remplaçant les DCP détectées par des codes. Retourne le document traité.

GET
/api/documents/{id}/download/{type}

Télécharger le document anonymisé

Téléchargez la version anonymisée d'un document en PDF, DOCX ou XLSX.

POST
/api/documents/batch-anonymize

Anonymisation par lots

Anonymisez plusieurs documents en une seule requête. Jusqu'à 50 documents traités simultanément.

Décodage

POST
/api/detokenize

Décoder du texte

Remplacez les codes dans une chaîne de texte par leurs valeurs originales depuis le coffre.

POST
/api/detokenize/file

Décoder un fichier

Uploadez un document encodé et recevez une version avec tous les codes restaurés à leurs valeurs originales.

Coffre & Registre de codes

GET
/api/vault/status

Statut du coffre

Obtenez les statistiques du coffre : total de codes, total de documents, taille du registre.

GET
/api/vault/tokens

Lister les codes

Récupérez toutes les correspondances code-original stockées dans le coffre.

POST
/api/vault/export

Exporter le coffre

Exportez l'intégralité du coffre en fichier JSON pour sauvegarde ou migration.

POST
/api/vault/import

Importer le coffre

Importez un JSON de coffre précédemment exporté pour restaurer les correspondances de codes.

Santé

GET
/api/health

Vérification de santé

Retourne le statut de santé du serveur. À utiliser pour la surveillance et les sondes de santé du load balancer.

Exemple

cURL — Upload, Detect, Anonymize
bash
# 1. Upload a document
curl -X POST http://localhost:8000/api/documents/upload \
  -F "file=@contract.pdf"
# → {"id": "abc123", "filename": "contract.pdf", "pages": 5}

# 2. Run PII detection
curl -X POST http://localhost:8000/api/documents/abc123/detect
# → {"status": "completed", "regions_count": 42}

# 3. Get detected regions
curl http://localhost:8000/api/documents/abc123/regions
# → [{"type": "PERSON", "text": "John Smith", "score": 0.98, ...}, ...]

# 4. Anonymize the document
curl -X POST http://localhost:8000/api/documents/abc123/anonymize
# → {"status": "completed", "tokens_created": 42}

# 5. Download anonymized PDF
curl -o contract-safe.pdf \
  http://localhost:8000/api/documents/abc123/download/pdf

SDK Python

Utilisez le moteur directement dans votre code Python pour une flexibilité maximale.

Python SDK
bash
import asyncio
from promptshield import ingest_document, detect_pii_on_page, anonymize_document

async def process(path: str):
    # Ingérer un document
    doc = await ingest_document(path, "contract.pdf")

    # Détecter les DCP sur chaque page
    for page in doc.pages:
        regions = detect_pii_on_page(page)
        print(f"Page {page.number}: {len(regions)} entities")

    # Anonymiser le document
    result = await anonymize_document(doc)
    print(f"Done: {result.tokens_created} tokens")

asyncio.run(process("contract.pdf"))

Gestion des erreurs

Toutes les réponses d'erreur suivent un format JSON standard avec un champ detail décrivant l'erreur.

400

Requête invalide — paramètres ou format de fichier incorrect

404

Non trouvé — l'ID du document n'existe pas

422

Erreur de validation — champs requis manquants

500

Erreur serveur — consultez les logs pour les détails

Error Response Format
bash
{
  "detail": "Document not found: abc123"
}

Limites de débit

L'API auto-hébergée n'a pas de limites de débit par défaut. Vous pouvez configurer la limitation via des variables d'environnement si nécessaire.

PromptShieldpromptShieldpromptShield

Anonymisation de documents propulsée par l'IA. Détectez et masquez les DCP hors ligne, en toute confidentialité.

Produit

  • Fonctions
  • Tarifs
  • Télécharger
  • Développeurs
  • Fonctionnement

Compte

  • Se connecter
  • S'inscrire
  • Tableau de bord

Mentions légales

  • Politique de confidentialité
  • Conditions d'utilisation
  • Contact
  • Taux de change
Canada flagProudly Canadian
© 2026 PromptShield. Tous droits réservés.