WebsitePublisher.ai

officiel

Publiez des sites web complets directement depuis n'importe quel client IA via une API — sans configuration d'hébergement, CMS ou paramétrage requis.

Que pouvez-vous faire avec WebsitePublisher Ai MCP ?

  • Gérer les pages — Créer, mettre à jour, modifier partiellement, supprimer et restaurer des pages HTML, avec un historique des versions et des différences disponibles sur demande.
  • Gérer les ressources — Lister, téléverser (en base64 ou via une URL), lire, modifier partiellement et supprimer des fichiers image, CSS et JS dans un projet.
  • Travailler avec des données dynamiques — Définir des types d’entités et des schémas, puis lister, créer, mettre à jour ou supprimer les enregistrements qui y sont stockés.
  • Exécuter des intégrations — Rechercher parmi plus de 100 intégrations, les configurer avec des clés API et exécuter leurs actions depuis le chat.
  • Stocker des secrets — Lister, stocker et supprimer des secrets chiffrés dans le coffre-fort du projet.
  • Planifier des tâches — Créer, lister et supprimer des tâches automatisées récurrentes, et vérifier leur prochaine heure d’exécution.

Documentation

🔗 Points de terminaison du serveur

Serveur MCP https://mcp.websitepublisher.ai

Spécification OpenAPI openapi.json

Découverte .well-known/mcp.json

Protocole Streamable HTTP + JSON-RPC 2.0

Authentification OAuth 2.1 (découverte automatique) ou jeton Bearer

Trois façons de se connecter. L’option A est la plus rapide — WebsitePublisher est répertorié dans l’annuaire des connecteurs d’Anthropic : une seule clic suffit et elle fonctionne avec tous les forfaits Claude, y compris le forfait gratuit. L’option B configure Claude Desktop pour vous et configure également Cursor, Windsurf et VS Code. L’option C consiste à configurer MCP manuellement.

1

Ouvrir la fiche dans Claude

Accédez directement à la fiche WebsitePublisher, ou ouvrez les paramètres dans claude.ai → Connecteurs et recherchez WebsitePublisher. Rien à coller, rien à configurer.

2

Cliquer sur Connecter et autoriser

Connectez-vous avec votre compte WebsitePublisher lorsque vous y êtes invité. Les outils sont immédiatement disponibles dans votre conversation. La fiche porte le badge Communauté — il s’agit du niveau d’évaluation d’Anthropic, et non d’une limitation.

🌐 Le connecteur Web fonctionne dans n’importe quel navigateur — aucune application de bureau ni Node.js n’est nécessaire. Idéal pour effectuer rapidement des modifications en déplacement.

Ajoutez ceci à votre claude_desktop_config.json :

{
  "mcpServers": {
    "websitepublisher": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.websitepublisher.ai/"]
    }
  }
}

💡 Lors de la première utilisation, une fenêtre de navigateur s’ouvre pour la connexion OAuth. Ensuite, les jetons sont mis en cache automatiquement.

Ajoutez WebsitePublisher comme serveur MCP distant dans Cursor. Cursor gère OAuth de manière native — aucun pont ni Node.js n’est nécessaire.

1

Ajouter la configuration MCP

Créez ou modifiez ~/.cursor/mcp.json (tous les projets), ou .cursor/mcp.json dans le dossier de votre projet :

{
  "mcpServers": {
    "websitepublisher": {
      "url": "https://mcp.websitepublisher.ai/"
    }
  }
}

2

Redémarrer Cursor

Quittez complètement l’application, puis rouvrez-la. Passez en mode Agent dans le panneau de discussion (Ctrl+L → bascule Agent).

3

S’authentifier

Lors de la première utilisation, Cursor ouvre votre navigateur pour vous connecter à WebsitePublisher. Après la connexion, vous êtes automatiquement redirigé vers Cursor et les outils sont disponibles.

💡 Vous utilisez encore l’ancienne configuration npx mcp-remote ? Elle continue de fonctionner, mais la configuration url ci-dessus est plus simple et ne nécessite pas Node.js.

VS Code 1.101+ prend en charge MCP distant natif avec découverte automatique OAuth. Aucun pont n’est nécessaire.

1

Ajouter la configuration MCP

Créez .vscode/mcp.json dans votre espace de travail :

{
  "servers": {
    "websitepublisher": {
      "type": "http",
      "url": "https://mcp.websitepublisher.ai/"
    }
  }
}

2

S’authentifier

Copilot découvre automatiquement OAuth. Connectez-vous lorsque le navigateur s’ouvre.

3

Utiliser le mode Agent

Passez en mode Agent dans Copilot Chat et commencez à créer.

💡 Notez le format différent : "servers" (et non "mcpServers") et "type": "http" + "url".

Devin Desktop prend en charge nativement Streamable HTTP et la découverte automatique OAuth. Aucun pont, aucun Node.js — juste une URL.

1

Ajouter la configuration MCP

Créez ou modifiez ~/.config/devin/mcp_config.json (Windows : %APPDATA%\devin\mcp_config.json), ou ouvrez-le depuis le panneau Cascade : menu … → MCPs → Open MCP config file :

{
  "mcpServers": {
    "websitepublisher": {
      "serverUrl": "https://mcp.websitepublisher.ai/"
    }
  }
}

2

Activer le serveur MCP

Redémarrez Devin Desktop. Dans le panneau Cascade (menu … → MCPs), activez le serveur MCP WebsitePublisher. Cliquez sur « Allow » lorsque vous êtes invité à ouvrir un site Web externe.

🌟 Devin Desktop offre l’intégration la plus simple — aucun pont, aucun npx, aucun Node.js requis.

Créez des copilotes personnalisés dotés des fonctionnalités de WebsitePublisher. L’intégration se fait via OAuth dans votre environnement Microsoft 365.

1

Créer un copilote

Dans Copilot Studio, créez un copilote ou ouvrez-en un existant.

2

Ajouter un connecteur MCP

Accédez à Settings → Connectors → Add MCP connector. Saisissez l’URL du serveur : https://mcp.websitepublisher.ai/

3

Configurer OAuth

Copilot Studio découvre automatiquement la configuration OAuth. Terminez le processus de connexion pour autoriser l’accès.

4

Activer les outils

Sélectionnez les outils WebsitePublisher auxquels votre copilote doit avoir accès, puis publiez-le.

⌨️ SDK pour développeurs

Gemini et Grok fonctionnent tous deux directement dans leurs applications Web via un connecteur personnalisé. Les développeurs peuvent également se connecter via le SDK Gemini ou l’API xAI.

Ajoutez WebsitePublisher comme application personnalisée dans l’application Gemini. Gemini s’enregistre et gère la connexion via OAuth — aucune clé API n’est nécessaire.

ℹ️ Google propose actuellement les applications personnalisées aux comptes Google personnels aux États-Unis, aux personnes âgées de 18 ans ou plus, avec Gemini réglé sur l’anglais et l’option Keep Activity activée. Pour les comptes professionnels ou scolaires, consultez Gemini Enterprise ci-dessous.

1

Ajouter une application personnalisée

Sur gemini.google.com, ouvrez Settings → Connected Apps et ajoutez une application personnalisée avec l’URL du serveur MCP https://mcp.websitepublisher.ai.

3

Commencer à créer

Dans une conversation Gemini, demandez : « Avec WebsitePublisher, liste mes projets. » L’application fonctionne également dans Spark sur le Web et sur mobile.

🏢 Gemini Enterprise : un administrateur Google Workspace ajoute https://mcp.websitepublisher.ai comme serveur MCP personnalisé pour l’organisation ; les membres de l’équipe se connectent ensuite avec leur propre compte WebsitePublisher.

Développeurs : SDK Gemini

Le SDK Gemini de Google intègre la prise en charge de MCP via le transport stdio avec npx.

Python

pip install google-genai mcp
import asyncio
from google import genai
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

client = genai.Client(api_key="your_gemini_api_key")

server_params = StdioServerParameters(
    command="npx",
    args=["-y", "websitepublisher-mcp@latest"],
    env={"WPS_TOKEN": "wps_your_session_token_here"}
)

async def main():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            response = await client.aio.models.generate_content(
                model="gemini-3.6-flash",
                contents="List my WebsitePublisher projects",
                config=genai.types.GenerateContentConfig(
                    temperature=0,
                    tools=[session],
                )
            )
            print(response.text)

asyncio.run(main())

JavaScript

npm install @google/genai @modelcontextprotocol/sdk
import { GoogleGenAI, mcpToTool } from "@google/genai";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
    command: "npx",
    args: ["-y", "websitepublisher-mcp@latest"],
    env: { WPS_TOKEN: "wps_your_session_token_here" }
});

const mcpClient = new Client({ name: "my-app", version: "1.0.0" });
await mcpClient.connect(transport);

const ai = new GoogleGenAI({ apiKey: "your_gemini_api_key" });

const response = await ai.models.generateContent({
    model: "gemini-3.6-flash",
    contents: "Create a homepage for my portfolio",
    config: { tools: [mcpToTool(mcpClient)] }
});

console.log(response.text);

Grok

Connecteur

Ajoutez WebsitePublisher comme connecteur personnalisé sur grok.com. Grok gère la connexion via OAuth.

1

Ajouter un connecteur personnalisé

Sur grok.com, ouvrez Settings → Connectors et ajoutez un connecteur personnalisé avec l’URL https://mcp.websitepublisher.ai.

3

Commencer à créer

Dans une conversation Grok, demandez : « Avec WebsitePublisher, liste mes projets. »

💡 Grok Business / Enterprise : un administrateur d’équipe doit ajouter le connecteur avant que les membres de l’équipe puissent l’utiliser.

Développeurs : API xAI

Grok prend également en charge MCP via le type d’outil remote_mcp dans le SDK xAI.

pip install xai-sdk
from xai_sdk import Client

client = Client(api_key="your_xai_api_key")

chat = client.chat.create(
    model="grok-4-1-fast",
    tools=[{
        "type": "remote_mcp",
        "server_url": "https://mcp.websitepublisher.ai",
        "server_label": "websitepublisher",
        "authorization": "wps_your_session_token_here"
    }]
)

response = chat.send("List my WebsitePublisher projects")
print(response.content)

🛠️ Outils disponibles (45)

Toutes les plateformes ont accès aux mêmes outils principaux, qui couvrent ensemble l’ensemble de la pile : pages et ressources, données, formulaires, authentification (administrateur, locataire et visiteur), intégrations et coffre-fort, tâches planifiées et historique des projets. Le nombre exact varie selon le projet — les intégrations configurées ajoutent automatiquement des outils dynamiques :

Projets

get_started

Commencez ici — renvoie votre projet et l’appel suivant exact

get_skill

Modèles de création, directives de conception, liste de vérification avant mise en ligne

list_projects

Liste tous vos projets

get_project_status

Nombre de pages et de ressources, domaine

create_project

Crée un projet (nom ; sous-domaine attribué)

Pages

list_pages

Liste les pages du projet

get_page

Récupère le HTML de la page et les informations de version

create_page

Crée une page HTML

update_page

Remplace la page entière

patch_page

Mise à jour partielle avec diff/patch

delete_page

Supprime une page

Gestion des versions

get_page_versions

Historique des versions avec différences

rollback_page

Restaure une version précédente

Ressources

list_assets

Liste les images, CSS et JS

upload_asset

Importe une ressource via base64 ou URL

delete_asset

Supprime une ressource

get_asset

Lit le contenu d’une ressource (JS, CSS, JSON, SVG)

patch_asset

Modifications partielles par recherche-remplacement sur les ressources

Entités (données dynamiques)

entities

Types d’entités : lister, créer, obtenir le schéma, mettre à jour, supprimer (opérations)

records

Lignes d’entité : lister, obtenir, créer, mettre à jour, supprimer (opérations)

Coffre-fort (secrets)

vault_list_secrets

Liste les clés secrètes stockées

vault_store_secret

Stocke un secret chiffré

vault_delete_secret

Supprime un secret

Intégrations

list_integrations

Intégrations disponibles

search_integrations

Recherche des intégrations selon vos besoins (plus de 100 disponibles)

setup_integration

Configure une intégration avec des clés API

execute_integration

Exécute une action d’intégration

remove_integration

Supprime la configuration d’une intégration

Formulaires (SAPI)

configure_form

Définit un formulaire et une action serveur

list_forms

Liste les formulaires configurés

remove_form

Supprime la configuration d’un formulaire

Suivi

set_tracking_scripts

Injecte GA, GTM, Pixel, etc.

get_tracking_scripts

Récupère la configuration de suivi actuelle

remove_tracking_scripts

Supprime tous les scripts de suivi

Éditeur visuel (WPE)

create_edit_session

Ouvre l’éditeur d’images visuel d’une page

get_edit_session_changes

Récupère les modifications en attente de la session de l’éditeur

Tâches planifiées (AAPI)

create_scheduled_task

Planifie des tâches récurrentes automatisées

list_scheduled_tasks

Liste toutes les tâches planifiées et leur prochaine exécution

delete_scheduled_task

Supprime une tâche planifiée

Gestion des tâches (TAPI)

tasks

Tâches avec historique : lister, obtenir, créer, add_history, rechercher, exporter (opérations)

Authentification des visiteurs et analyses (SAPI)

configure_visitor_auth

Configure l’authentification des visiteurs

get_visitor_auth_config

Récupère la configuration d’authentification des visiteurs

get_analytics

Analyses des visiteurs du projet

get_integration_schema

Récupère le schéma complet de l’intégration et ses points de terminaison

🔗 Outils d’intégration dynamiques

En plus des 45 outils principaux, WebsitePublisher génère des outils supplémentaires de manière dynamique en fonction des intégrations configurées dans votre projet. Chaque intégration expose ses propres points de terminaison via execute_integration — aucun outil MCP supplémentaire n’est nécessaire.

149 intégrations disponibles dans les catégories suivantes :

IA

Anthropic, OpenAI, Gemini, Groq, Mistral, Replicate, ElevenLabs, Deepgram, Stability, Perplexity

Commerce électronique

Catalogue de produits, panier, paiement, commandes, inventaire, factures, remises, avis, listes de souhaits

Paiements

Stripe, Mollie, PayPal

E-mail

Resend, SendGrid, Mailgun, SMTP, Mailchimp, Brevo, Kit

Réseaux sociaux

LinkedIn, Twitter/X

Messagerie

Slack, Discord, Telegram, Twilio (SMS + WhatsApp)

Expédition

PostNL, SendCloud

CRM et productivité

HubSpot, Notion, Linear, Todoist, Airtable, Supabase

Médias

Cloudinary, Unsplash, Pexels, Giphy, Imgur, Vimeo, YouTube

Données

Google Places, NewsAPI, OpenWeather, Overheid.io KVK, Web Scraper

Plateforme

Blog, commentaires, flux, téléchargements de fichiers, modèles d’e-mail, analyses, Schema.org, et plus encore

Développement et surveillance

GitHub, Sentry, Cal.com

📖 Consultez la documentation des intégrations pour obtenir la liste complète des points de terminaison et des guides de configuration.

💬 Exemples de requêtes

Ces exemples fonctionnent sur toutes les plateformes :

🔧 Dépannage

ChatGPT : WebsitePublisher n’est pas utilisé

Si ChatGPT répond de lui-même (par exemple avec un aperçu de page dans la conversation qui n’est publié nulle part), commencez votre message par @WebsitePublisher. Si l’application ne répond toujours pas, vérifiez qu’elle est connectée dans les paramètres de ChatGPT et reconnectez-la pour actualiser la connexion OAuth. Vous utilisez encore notre Custom GPT ? Il cessera de fonctionner lorsque OpenAI retirera les Custom GPT le 11 décembre 2026 ; passez à l’application WebsitePublisher.

Claude : les outils ne s’affichent pas

Quittez complètement Claude Desktop (ne vous contentez pas de fermer la fenêtre), puis rouvrez-le. Si les outils n’apparaissent toujours pas, relancez l’application Connect pour reconfigurer.

Cursor : les outils ne se chargent pas

Assurez-vous d’être en mode Agent (et non en mode Ask). Vérifiez que ~/.cursor/mcp.json contient la configuration correcte. Redémarrez complètement Cursor.

Devin Desktop (Windsurf) : serveur MCP introuvable

Après avoir ajouté la configuration, redémarrez Devin Desktop et activez manuellement le serveur MCP dans le panneau Cascade. Il s’agit d’une mesure de sécurité de Devin Desktop : les serveurs doivent être activés explicitement.

GitHub Copilot : connexion impossible

Assurez-vous d’utiliser VS Code 1.101+. Vérifiez que la configuration utilise "servers" (et non "mcpServers") et "type": "http". Passez en mode Agent dans Copilot Chat.

Mistral : les outils ne s’affichent pas dans la conversation

Après avoir ajouté le connecteur, veillez à l’activer dans votre conversation. Cliquez sur le bouton Tools (icône à 4 carrés) sous la zone de saisie et vérifiez que WebsitePublisher est activé. Si le connecteur n’apparaît pas dans l’annuaire, essayez de rechercher « WebsitePublisher » (en un seul mot).

Gemini : l’option « Add custom app » n’est pas disponible

Google limite actuellement les applications personnalisées aux comptes personnels aux États-Unis avec Gemini réglé sur l’anglais. Les comptes professionnels ou scolaires doivent passer par Gemini Enterprise (configuration par un administrateur). Tous les autres peuvent utiliser le SDK présenté ci-dessus.

Grok : connecté, mais aucun outil

Supprimez le connecteur, puis ajoutez-le à nouveau. Vérifiez que la page de connexion WebsitePublisher s’est bien affichée — si Grok indique « connecté » sans vous demander de vous connecter, les outils ne se chargeront pas.

OAuth : le navigateur ne s’ouvre pas

Pour les configurations basées sur mcp-remote (Claude Desktop, anciennes configurations Cursor) : vérifiez que npx fonctionne dans votre terminal. Essayez d’exécuter npx -y mcp-remote --help pour vérifier.

Jeton expiré

Les jetons OAuth sont actualisés automatiquement sur la plupart des plateformes. Pour les utilisateurs du SDK : obtenez un nouveau jeton de session depuis le tableau de bord.

💡 Test rapide : demandez à votre IA « Liste mes projets WebsitePublisher » — si cela fonctionne, vous êtes connecté !

📚 Ressources

⬇️ Connecter l’application 🎛️ Tableau de bord 🤖 IA prises en charge 📄 Spécification OpenAPI 🔍 Découverte 🐙 Dépôt GitHub 🔌 Protocole MCP 📖 Documentation PAPI 🔗 Intégrations