LeoYeAI/openclaw-master-skills

Buffer

Accédez à l'API GraphQL de Buffer avec une authentification gérée. Planifiez et gérez des publications sur les réseaux sociaux sur Instagram, Facebook, Twitter, LinkedIn, TikTok et plus.

Démarrage rapide

# Obtenir les informations du compte avec les organisations
python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": "query { account { id email organizations { id name } } }"
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

URL de base

https://gateway.maton.ai/buffer/

Buffer utilise un point d'accès GraphQL unique. Toutes les requêtes et mutations sont envoyées sous forme de requêtes POST à ce point d'accès.

Authentification

Toutes les requêtes nécessitent la clé API Maton dans l'en-tête Authorization :

Authorization: Bearer $MATON_API_KEY

Variable d'environnement : Définissez votre clé API comme MATON_API_KEY :

export MATON_API_KEY="VOTRE_CLÉ_API"

Obtenir votre clé API

1. Connectez-vous ou créez un compte sur maton.ai
2. Allez dans maton.ai/settings
3. Copiez votre clé API

Gestion des connexions

Gérez vos connexions Buffer sur https://ctrl.maton.ai.

Lister les connexions

python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections?app=buffer&status=ACTIVE')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Créer une connexion

python <<'EOF'
import urllib.request, os, json
data = json.dumps({'app': 'buffer'}).encode()
req = urllib.request.Request('https://ctrl.maton.ai/connections', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Obtenir une connexion

python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections/{connection_id}')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Réponse :

{
  "connection": {
    "connection_id": "a71282a3-52be-473d-9273-22b4546dc146",
    "status": "ACTIVE",
    "creation_time": "2026-03-12T00:18:28.327860Z",
    "last_updated_time": "2026-03-12T00:18:42.818009Z",
    "url": "https://connect.maton.ai/?session_token=...",
    "app": "buffer",
    "metadata": {},
    "method": "API_KEY"
  }
}

Supprimer une connexion

python <<'EOF'
import urllib.request, os, json
req = urllib.request.Request('https://ctrl.maton.ai/connections/{connection_id}', method='DELETE')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Spécifier une connexion

Si vous avez plusieurs connexions Buffer, spécifiez laquelle utiliser avec l'en-tête Maton-Connection :

python <<'EOF'
import urllib.request, os, json
data = json.dumps({"query": "query { account { id } }"}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
req.add_header('Maton-Connection', 'a71282a3-52be-473d-9273-22b4546dc146')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Si omis, la passerelle utilise la connexion active par défaut (la plus ancienne).

Référence de l'API

Obtenir le compte

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query {
        account {
            id
            email
            name
            avatar
            timezone
            createdAt
            preferences {
                timeFormat
                startOfWeek
            }
        }
    }
    """
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Réponse :

{
  "data": {
    "account": {
      "id": "69846f7479b75e6487fa3482",
      "email": "[email protected]",
      "name": "John Doe",
      "avatar": "https://...",
      "timezone": "America/New_York",
      "createdAt": "2024-01-15T10:30:00Z",
      "preferences": {
        "timeFormat": "12h",
        "startOfWeek": "sunday"
      }
    }
  }
}

Obtenir les organisations

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query {
        account {
            organizations {
                id
                name
                channels {
                    id
                    name
                    service
                    avatar
                    isDisconnected
                }
            }
        }
    }
    """
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Réponse :

{
  "data": {
    "account": {
      "organizations": [
        {
          "id": "69846f7479b75e6487fa3484",
          "name": "My Organization",
          "channels": [
            {
              "id": "channel123",
              "name": "My Twitter",
              "service": "twitter",
              "avatar": "https://...",
              "isDisconnected": false
            }
          ]
        }
      ]
    }
  }
}

Obtenir les canaux

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query GetChannels($organizationId: OrganizationId!) {
        channels(organizationId: $organizationId) {
            id
            name
            service
            displayName
            avatar
            timezone
            isDisconnected
            isQueuePaused
            postingSchedule {
                days
                times
            }
        }
    }
    """,
    "variables": {
        "organizationId": "69846f7479b75e6487fa3484"
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Obtenir un canal unique

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query GetChannel($channelId: ChannelId!) {
        channel(channelId: $channelId) {
            id
            name
            service
            displayName
            avatar
            timezone
            postingSchedule {
                days
                times
            }
            postingGoal {
                postsPerWeek
                progress
            }
        }
    }
    """,
    "variables": {
        "channelId": "channel123"
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Lister les publications

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query GetPosts($channelId: ChannelId!, $status: PostStatus, $first: Int) {
        posts(channelId: $channelId, status: $status, first: $first) {
            edges {
                node {
                    id
                    text
                    status
                    createdAt
                    dueAt
                    sentAt
                    channelService
                }
            }
            pageInfo {
                hasNextPage
                endCursor
            }
        }
    }
    """,
    "variables": {
        "channelId": "channel123",
        "status": "scheduled",
        "first": 10
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Valeurs du statut de publication :

• draft - Enregistré comme brouillon
• scheduled - Planifié pour publication
• sent - Publié
• failed - Échec de la publication

Obtenir une publication unique

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query GetPost($postId: PostId!) {
        post(id: $postId) {
            id
            text
            status
            createdAt
            dueAt
            sentAt
            author {
                name
                email
            }
            channel {
                id
                name
                service
            }
            assets {
                id
                url
                type
            }
        }
    }
    """,
    "variables": {
        "postId": "post123"
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Créer une publication

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation CreatePost($input: CreatePostInput!) {
        createPost(input: $input) {
            ... on Post {
                id
                text
                status
                dueAt
            }
            ... on InvalidInputError {
                message
            }
            ... on UnauthorizedError {
                message
            }
        }
    }
    """,
    "variables": {
        "input": {
            "channelId": "channel123",
            "text": "Bonjour depuis l'API Buffer !",
            "schedulingType": "scheduled",
            "dueAt": "2026-03-15T14:00:00Z",
            "mode": "queue"
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Champs CreatePostInput :

• channelId (obligatoire) : ID du canal cible
• text : Contenu de la publication
• schedulingType (obligatoire) : "scheduled", "draft" ou "now"
• dueAt : Date/heure ISO 8601 pour les publications planifiées
• mode (obligatoire) : "queue" ou "share"
• assets : Pièces jointes multimédia
• tagIds : Tags de contenu
• metadata : Options spécifiques à la plateforme (voir la section Métadonnées de plateforme)
• ideaId : Lier la publication à une idée existante
• draftId : Créer à partir d'un brouillon existant
• source : Origine de la publication
• aiAssisted : Indique si l'IA a aidé à créer le contenu
• saveToDraft : Enregistrer comme brouillon au lieu de planifier

Créer une publication avec les métadonnées Instagram

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation CreatePost($input: CreatePostInput!) {
        createPost(input: $input) {
            ... on Post { id text status }
            ... on InvalidInputError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "channelId": "instagram_channel_id",
            "text": "Découvrez notre dernière publication ! #photographie",
            "schedulingType": "scheduled",
            "dueAt": "2026-03-15T14:00:00Z",
            "mode": "queue",
            "metadata": {
                "instagram": {
                    "type": "post",
                    "firstComment": "Suivez-nous pour plus !",
                    "shouldShareToFeed": True
                }
            }
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Créer un fil Twitter

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation CreatePost($input: CreatePostInput!) {
        createPost(input: $input) {
            ... on Post { id text status }
            ... on InvalidInputError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "channelId": "twitter_channel_id",
            "text": "Premier tweet du fil",
            "schedulingType": "scheduled",
            "dueAt": "2026-03-15T14:00:00Z",
            "mode": "queue",
            "metadata": {
                "twitter": {
                    "thread": [
                        {"text": "Deuxième tweet du fil"},
                        {"text": "Troisième tweet du fil"}
                    ]
                }
            }
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Créer une publication LinkedIn avec lien

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation CreatePost($input: CreatePostInput!) {
        createPost(input: $input) {
            ... on Post { id text status }
            ... on InvalidInputError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "channelId": "linkedin_channel_id",
            "text": "Article intéressant sur notre blog !",
            "schedulingType": "scheduled",
            "dueAt": "2026-03-15T14:00:00Z",
            "mode": "queue",
            "metadata": {
                "linkedin": {
                    "link": {
                        "url": "https://example.com/blog",
                        "title": "Notre dernier article de blog"
                    }
                }
            }
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Mettre à jour une publication

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation UpdatePost($input: UpdatePostInput!) {
        updatePost(input: $input) {
            ... on Post { id text status dueAt }
            ... on InvalidInputError { message }
            ... on UnauthorizedError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "postId": "post123",
            "text": "Contenu mis à jour !",
            "schedulingType": "scheduled",
            "dueAt": "2026-03-16T10:00:00Z",
            "mode": "queue"
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Supprimer une publication

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation DeletePost($input: DeletePostInput!) {
        deletePost(input: $input) {
            ... on DeletePostSuccess { id }
            ... on InvalidInputError { message }
            ... on UnauthorizedError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "postId": "post123",
            "keepQueueOrder": true
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Métadonnées de plateforme

Instagram

{
    "instagram": {
        "type": "post",
        "firstComment": "Commentaire sur le post",
        "shouldShareToFeed": true
    }
}

Twitter

{
    "twitter": {
        "thread": [
            {"text": "Deuxième tweet"},
            {"text": "Troisième tweet"}
        ]
    }
}

Passez "thread": [] pour publier un tweet unique.

LinkedIn

{
    "linkedin": {
        "link": {
            "url": "https://example.com",
            "title": "Titre du lien"
        }
    }
}

Facebook

{
    "facebook": {
        "isSharingLink": true
    }
}

TikTok

{
    "tiktok": {
        "isWatchInFeedEnabled": true
    }
}

Idées de contenu

Lister les idées

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    query GetIdeas($organizationId: OrganizationId!, $first: Int) {
        ideas(organizationId: $organizationId, first: $first) {
            id
            text
            status
            createdAt
            scheduledAt
            channelNames
            tags { id name }
        }
    }
    """,
    "variables": {
        "organizationId": "69846f7479b75e6487fa3484",
        "first": 20
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Valeurs du statut : idea, in_progress, done, archived

Créer une idée

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation CreateIdea($input: CreateIdeaInput!) {
        createIdea(input: $input) {
            ... on Idea { id text status createdAt }
            ... on InvalidInputError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "organizationId": "69846f7479b75e6487fa3484",
            "text": "Nouvelle idée de contenu",
            "status": "idea",
            "tags": ["tag1", "tag2"]
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Gestion de la file d'attente

Mettre en pause/reprendre la file d'attente

python <<'EOF'
import urllib.request, os, json
data = json.dumps({
    "query": """
    mutation SetQueuePaused($input: SetQueuePausedInput!) {
        setQueuePaused(input: $input) {
            ... on Channel { id isQueuePaused }
            ... on InvalidInputError { message }
            ... on UnauthorizedError { message }
        }
    }
    """,
    "variables": {
        "input": {
            "channelId": "channel123",
            "isQueuePaused": true
        }
    }
}).encode()
req = urllib.request.Request('https://gateway.maton.ai/buffer/', data=data, method='POST')
req.add_header('Authorization', f'Bearer {os.environ["MATON_API_KEY"]}')
req.add_header('Content-Type', 'application/json')
print(json.dumps(json.load(urllib.request.urlopen(req)), indent=2))
EOF

Meilleures pratiques

1. Mise en cache des ID : Mettez en cache les organisations et les ID de canal car ils changent rarement.
2. Limites de débit : Respectez les limites de débit de l'API Buffer ; espacez les requêtes en masse.
3. Gestion des erreurs : Gérez toujours les fragments InvalidInputError et UnauthorizedError.
4. Métadonnées : Utilisez le champ metadata pour les options spécifiques à la plateforme uniquement lorsque nécessaire.
5. Création de brouillon : Utilisez draft comme schedulingType ou définissez saveToDraft: true pour enregistrer sans planifier.
6. Threads Twitter : Incluez toujours le texte du premier tweet dans le champ text principal et les tweets suivants dans metadata.twitter.thread.

Limites de l'API

Cette passerelle prend en charge les opérations Buffer suivantes :

• Gestion des comptes et des organisations
• Gestion des canaux
• Opérations CRUD sur les publications
• Gestion des idées
• Contrôle de la file d'attente

Non pris en charge :

• Analyse/Rapports
• Gestion des campagnes
• Recherche/Modération de contenu généré par l'utilisateur