> ## Documentation Index
> Fetch the complete documentation index at: https://docs.linkuma.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Intégrations & Automatisation

> Connectez l'API Linkuma à vos outils no-code et scripts personnalisés pour automatiser vos campagnes de backlinks.

# Intégrations & Automatisation

L'API Linkuma s'intègre nativement avec les principaux outils d'automatisation du marché. Cette page vous guide pas à pas pour connecter Linkuma à votre stack, qu'il s'agisse d'outils no-code ou de scripts sur mesure.

<Info>
  Base URL de l'API : `https://app.linkuma.com/api/v1/`
  Authentification : Bearer token dans le header `Authorization`
  Rate limit : 60 requêtes/minute
</Info>

<Note>
  **Pourquoi automatiser ?** 86% des professionnels du marketing utilisent désormais des outils IA et d'automatisation pour le SEO (DemandSage 2025). Les experts expérimentés génèrent **3.57× plus de liens** que les débutants, en grande partie grâce à l'automatisation de la prospection et du suivi. L'API Linkuma vous donne cet avantage.
</Note>

***

## Zapier

Zapier vous permet de connecter Linkuma à des centaines d'applications sans écrire une seule ligne de code.

### Prérequis

<Steps>
  <Step title="Récupérer votre token API">
    Rendez-vous dans **Paramètres → API** sur votre espace Linkuma et copiez votre Bearer token.
  </Step>

  <Step title="Créer un Zap">
    Dans Zapier, cliquez sur **Create Zap**, puis choisissez votre déclencheur (Trigger).
  </Step>

  <Step title="Configurer le module Webhook ou HTTP">
    Sélectionnez l'action **Webhooks by Zapier → POST** ou **Custom Request** selon le sens du flux.
  </Step>
</Steps>

### Scénario 1 : Nouvelle commande → Notification Slack

Ce Zap interroge l'API Linkuma toutes les heures et envoie une alerte Slack dès qu'une nouvelle commande est détectée.

<Tabs>
  <Tab title="Configuration Trigger">
    **Trigger : Schedule by Zapier**

    * Fréquence : `Every Hour`

    **Action 1 : Webhooks by Zapier → GET**

    | Champ   | Valeur                                                          |
    | ------- | --------------------------------------------------------------- |
    | URL     | `https://app.linkuma.com/api/v1/orders?status=pending&limit=10` |
    | Headers | `Authorization: Bearer VOTRE_TOKEN`                             |
    | Method  | GET                                                             |
  </Tab>

  <Tab title="Configuration Action Slack">
    **Action 2 : Slack → Send Channel Message**

    | Champ   | Valeur                                                                    |
    | ------- | ------------------------------------------------------------------------- |
    | Channel | `#seo-commandes`                                                          |
    | Message | `Nouvelle commande Linkuma : {{order_id}}, {{project_name}}, {{amount}}€` |

    <Tip>
      Utilisez le **Filter** de Zapier entre les deux actions pour n'envoyer la notification que si le tableau de résultats n'est pas vide.
    </Tip>
  </Tab>
</Tabs>

### Scénario 2 : Rapport hebdomadaire automatique

<Steps>
  <Step title="Trigger : Schedule (chaque lundi 9h)">
    Configurez le déclencheur sur `Every Week` → lundi, 9:00.
  </Step>

  <Step title="Action : Appel API Linkuma">
    ```http theme={null}
    GET https://app.linkuma.com/api/v1/orders?status=delivered&period=last_week
    Authorization: Bearer VOTRE_TOKEN
    ```
  </Step>

  <Step title="Action : Envoyer par email (Gmail ou Outlook)">
    Formatez le corps du mail avec les champs dynamiques récupérés : `total_orders`, `total_spent`, `links_delivered`.
  </Step>
</Steps>

<Warning>
  Le rate limit de 60 req/min s'applique également aux appels déclenchés par Zapier. Si vous chaînez plusieurs Zaps sur le même compte, surveillez votre consommation depuis **Paramètres → API → Logs**.
</Warning>

***

## Make (ex-Integromat)

Make offre une interface visuelle puissante pour construire des scénarios complexes avec branchements conditionnels.

### Configurer le module HTTP

<Steps>
  <Step title="Créer un scénario">
    Dans Make, cliquez sur **Create a new scenario**.
  </Step>

  <Step title="Ajouter le module HTTP → Make a Request">
    Configurez le module avec les paramètres suivants :

    ```
    URL      : https://app.linkuma.com/api/v1/orders
    Method   : GET
    Headers  : Authorization: Bearer VOTRE_TOKEN
    Parse    : JSON (activé)
    ```
  </Step>

  <Step title="Chaîner les modules suivants">
    Branchez un **Router** pour traiter chaque commande individuellement, puis ajoutez vos modules cibles (Airtable, Notion, Google Sheets, Slack…).
  </Step>
</Steps>

### Scénario : Commande livrée → Mise à jour Airtable

<CodeGroup>
  ```json Configuration du module HTTP theme={null}
  {
    "url": "https://app.linkuma.com/api/v1/orders/{{order_id}}",
    "method": "GET",
    "headers": [
      {
        "name": "Authorization",
        "value": "Bearer VOTRE_TOKEN"
      }
    ]
  }
  ```

  ```json Payload vers Airtable theme={null}
  {
    "fields": {
      "Commande ID": "{{order_id}}",
      "Statut": "{{status}}",
      "URL cible": "{{target_url}}",
      "Lien livré": "{{delivered_url}}",
      "Date livraison": "{{delivered_at}}"
    }
  }
  ```
</CodeGroup>

<Note>
  Dans Make, activez l'option **Instant trigger** sur le webhook entrant si vous souhaitez un traitement en temps réel plutôt que par polling.
</Note>

***

## N8n (open source)

N8n est une alternative open source à Zapier et Make, auto-hébergeable. Idéale si vous gérez votre propre infrastructure.

### Workflow exemple : Monitoring des commandes

<Steps>
  <Step title="Ajouter un nœud Cron">
    * Expression : `0 * * * *` (toutes les heures)
  </Step>

  <Step title="Ajouter un nœud HTTP Request">
    ```
    Method  : GET
    URL     : https://app.linkuma.com/api/v1/orders?status=in_progress
    Auth    : Header Auth
    Name    : Authorization
    Value   : Bearer VOTRE_TOKEN
    ```
  </Step>

  <Step title="Ajouter un nœud IF">
    Condition : `{{ $json.data.length > 0 }}`
    Branche **true** → envoi Telegram / email / Slack
    Branche **false** → aucune action
  </Step>

  <Step title="Ajouter un nœud Telegram (ou Email)">
    Configurez le message avec les données dynamiques issues du nœud HTTP.
  </Step>
</Steps>

<CodeGroup>
  ```json Exemple de réponse API Linkuma theme={null}
  {
    "data": [
      {
        "order_id": "lnk_ord_8472",
        "project_name": "Mon site e-commerce",
        "target_url": "https://monsite.fr/produit",
        "status": "in_progress",
        "anchor": "chaussures running",
        "amount": 35,
        "created_at": "2026-02-20T14:30:00Z"
      }
    ],
    "meta": {
      "total": 1,
      "page": 1
    }
  }
  ```

  ```json Nœud HTTP Request (format n8n) theme={null}
  {
    "method": "GET",
    "url": "https://app.linkuma.com/api/v1/orders",
    "authentication": "headerAuth",
    "headerParameters": {
      "parameter": [
        {
          "name": "Authorization",
          "value": "Bearer VOTRE_TOKEN"
        }
      ]
    },
    "queryParameters": {
      "parameter": [
        { "name": "status", "value": "in_progress" },
        { "name": "limit", "value": "50" }
      ]
    }
  }
  ```
</CodeGroup>

***

## Script Python

Pour une intégration complète et personnalisée, voici un script Python prêt à l'emploi pour passer une commande via l'API Linkuma.

### Installation

```bash theme={null}
pip install requests
```

### Exemple complet : Commande automatisée

```python theme={null}
import requests
import json
from datetime import datetime

# Configuration
API_BASE = "https://app.linkuma.com/api/v1"
API_TOKEN = "VOTRE_TOKEN_ICI"

HEADERS = {
    "Authorization": f"Bearer {API_TOKEN}",
    "Content-Type": "application/json",
    "Accept": "application/json"
}


def get_projects():
    """Récupère la liste de vos projets Linkuma."""
    response = requests.get(f"{API_BASE}/projects", headers=HEADERS)
    response.raise_for_status()
    return response.json()["data"]


def place_order(project_id: str, target_url: str, anchor: str, budget: int):
    """
    Passe une commande de backlink.

    Args:
        project_id : ID du projet Linkuma
        target_url : URL de destination du lien
        anchor     : Texte d'ancre souhaité
        budget     : Budget max en euros (7 à 140)
    """
    payload = {
        "project_id": project_id,
        "target_url": target_url,
        "anchor": anchor,
        "budget_max": budget,
        "niche": "auto"  # Linkuma choisit automatiquement le site le plus pertinent
    }

    response = requests.post(
        f"{API_BASE}/orders",
        headers=HEADERS,
        json=payload
    )
    response.raise_for_status()
    return response.json()


def get_order_status(order_id: str):
    """Vérifie le statut d'une commande."""
    response = requests.get(f"{API_BASE}/orders/{order_id}", headers=HEADERS)
    response.raise_for_status()
    return response.json()["data"]


# --- Exemple d'utilisation ---
if __name__ == "__main__":

    # 1. Lister les projets disponibles
    projects = get_projects()
    print(f"Projets disponibles : {len(projects)}")
    for p in projects:
        print(f"  - {p['name']} (ID: {p['id']})")

    # 2. Passer une commande
    order = place_order(
        project_id=projects[0]["id"],
        target_url="https://monsite.fr/categorie/running",
        anchor="chaussures de running pas cher",
        budget=35
    )
    order_id = order["data"]["order_id"]
    print(f"\nCommande créée : {order_id}")

    # 3. Vérifier le statut
    status = get_order_status(order_id)
    print(f"Statut : {status['status']}")
    print(f"Créée le : {status['created_at']}")
```

<Tip>
  Ajoutez une logique de retry avec backoff exponentiel si vous passez plus de 30 commandes en rafale, afin de respecter le rate limit de 60 req/min.
</Tip>

***

## Script Node.js

Idéal pour intégrer Linkuma dans un back-end JavaScript ou un pipeline CI/CD.

### Exemple : Monitoring des commandes en temps réel

```javascript theme={null}
// linkuma-monitor.mjs
// Usage : node linkuma-monitor.mjs

const API_BASE = "https://app.linkuma.com/api/v1";
const API_TOKEN = "VOTRE_TOKEN_ICI";

const headers = {
  Authorization: `Bearer ${API_TOKEN}`,
  "Content-Type": "application/json",
  Accept: "application/json",
};

/**
 * Récupère toutes les commandes selon un statut donné.
 * @param {string} status - pending | in_progress | delivered | cancelled
 */
async function getOrders(status = "in_progress") {
  const url = new URL(`${API_BASE}/orders`);
  url.searchParams.set("status", status);
  url.searchParams.set("limit", "100");

  const res = await fetch(url.toString(), { headers });
  if (!res.ok) throw new Error(`API error: ${res.status} ${res.statusText}`);
  return res.json();
}

/**
 * Affiche un résumé coloré dans le terminal.
 */
function printSummary(orders) {
  const total = orders.meta?.total ?? orders.data.length;
  console.log(`\n=== Linkuma Monitor : ${new Date().toLocaleString("fr-FR")} ===`);
  console.log(`Commandes en cours : ${total}\n`);

  for (const order of orders.data) {
    const statusIcon = order.status === "delivered" ? "✅" : "⏳";
    console.log(
      `${statusIcon} [${order.order_id}] ${order.target_url}, ${order.anchor} (${order.amount}€)`
    );
  }
}

/**
 * Boucle de monitoring : interroge l'API toutes les 5 minutes.
 */
async function startMonitor(intervalMs = 5 * 60 * 1000) {
  console.log("Démarrage du monitoring Linkuma...");

  const run = async () => {
    try {
      const orders = await getOrders("in_progress");
      printSummary(orders);
    } catch (err) {
      console.error("Erreur API Linkuma :", err.message);
    }
  };

  await run(); // Premier appel immédiat
  setInterval(run, intervalMs);
}

startMonitor();
```

***

## Google Sheets : Apps Script

Créez un tableau de bord Linkuma directement dans Google Sheets, mis à jour automatiquement.

### Installation

<Steps>
  <Step title="Ouvrir l'éditeur Apps Script">
    Dans votre Google Sheet, allez dans **Extensions → Apps Script**.
  </Step>

  <Step title="Coller le script ci-dessous">
    Remplacez `VOTRE_TOKEN_ICI` par votre Bearer token Linkuma.
  </Step>

  <Step title="Configurer le déclencheur">
    Dans Apps Script, cliquez sur **Déclencheurs (horloge)** → Ajouter un déclencheur → `syncLinkuma` → Déclencheur temporel → Toutes les heures.
  </Step>
</Steps>

```javascript theme={null}
// Google Apps Script : Linkuma Reporting
// Coller dans Extensions → Apps Script

const LINKUMA_TOKEN = "VOTRE_TOKEN_ICI";
const LINKUMA_BASE = "https://app.linkuma.com/api/v1";

function syncLinkuma() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Commandes")
    || SpreadsheetApp.getActiveSpreadsheet().insertSheet("Commandes");

  // En-têtes
  const headers = [
    "ID Commande", "Projet", "URL cible", "Ancre",
    "Statut", "Montant (€)", "Créée le", "Livrée le"
  ];

  const response = UrlFetchApp.fetch(`${LINKUMA_BASE}/orders?limit=200`, {
    method: "GET",
    headers: {
      Authorization: `Bearer ${LINKUMA_TOKEN}`,
      Accept: "application/json"
    },
    muteHttpExceptions: true
  });

  if (response.getResponseCode() !== 200) {
    Logger.log("Erreur API : " + response.getContentText());
    return;
  }

  const data = JSON.parse(response.getContentText());
  const orders = data.data || [];

  // Écriture dans le sheet
  sheet.clearContents();
  sheet.appendRow(headers);

  orders.forEach(order => {
    sheet.appendRow([
      order.order_id,
      order.project_name,
      order.target_url,
      order.anchor,
      order.status,
      order.amount,
      order.created_at ? new Date(order.created_at).toLocaleDateString("fr-FR") : "",
      order.delivered_at ? new Date(order.delivered_at).toLocaleDateString("fr-FR") : ""
    ]);
  });

  // Mise en forme
  const range = sheet.getRange(1, 1, 1, headers.length);
  range.setBackground("#1a1a2e").setFontColor("#ffffff").setFontWeight("bold");

  Logger.log(`Synchronisation terminée : ${orders.length} commandes importées.`);
}
```

<Note>
  Pour les agences gérant plusieurs clients, dupliquez l'onglet "Commandes" et adaptez le paramètre `project_id` dans l'URL de l'API afin de filtrer par projet.
</Note>

***

## Récapitulatif des intégrations

<CardGroup cols={3}>
  <Card title="Zapier" icon="bolt">
    Idéal pour les équipes non-techniques. Connectez Linkuma à Slack, Gmail, Notion ou Airtable en quelques clics.
  </Card>

  <Card title="Make" icon="diagram-project">
    Puissant pour les scénarios complexes avec logique conditionnelle. Parfait pour les agences.
  </Card>

  <Card title="N8n" icon="code-fork">
    Open source et auto-hébergeable. Zéro frais mensuels, contrôle total de vos données.
  </Card>

  <Card title="Python" icon="python">
    Pour les développeurs et data analysts. Automatisez des centaines de commandes en quelques lignes.
  </Card>

  <Card title="Node.js" icon="js">
    Intégrez Linkuma dans vos applications web ou pipelines backend JavaScript.
  </Card>

  <Card title="Google Sheets" icon="table">
    Reporting automatique sans code. Partagez les résultats avec vos clients directement depuis Drive.
  </Card>
</CardGroup>