Instagram Graph API Nutzung 2026: Anleitung

Das Wichtigste in Kürze

Die Instagram Graph API ermöglicht Entwicklern, Instagram Business- und Creator-Konten programmatisch zu verwalten. Sie nutzt die Facebook Login OAuth 2.0-Authentifizierung, GraphQL-basierte Endpunkte für die Veröffentlichung von Inhalten, Insights, Kommentare und Nachrichten, mit Ratenbegrenzungen von 200 Aufrufen pro Stunde pro App. Dieser Leitfaden behandelt die Einrichtung der Authentifizierung, die Veröffentlichung von Inhalten, das Abrufen von Insights, die Kommentarverwaltung und Strategien für die Produktionsintegration.

Einführung

Instagram hat über 2 Milliarden monatlich aktive Nutzer, wobei über 200 Millionen Unternehmen Instagram Business-Konten nutzen. Für Entwickler, die Tools zur Social-Media-Verwaltung, Analyseplattformen oder E-Commerce-Integrationen erstellen, ist die Integration der Instagram Graph API unerlässlich, um dieses riesige Publikum zu erreichen.

Hier ist die Realität: Social Media Manager, die mehr als 10 Konten betreuen, verlieren wöchentlich 20-30 Stunden mit manuellem Posten, dem Beantworten von Kommentaren und dem Zusammenstellen von Analysen. Eine solide Instagram API-Integration automatisiert die Veröffentlichung von Inhalten, die Kommentarmoderation, die Sentimentanalyse und das Leistungsreporting.

Dieser Leitfaden führt Sie durch den gesamten Integrationsprozess der Instagram Graph API. Sie lernen die Facebook Login-Authentifizierung, die Veröffentlichung von Inhalten, Medien-Insights, die Kommentarverwaltung, die Webhook-Integration und Strategien für die Produktionsbereitstellung kennen. Am Ende werden Sie eine produktionsreife Instagram-Integration haben.

Was ist die Instagram Graph API?

Die Instagram Graph API bietet programmatischen Zugriff auf Instagram Business- und Creator-Konten über die Facebook Graph API. Die API handhabt:

• Inhaltsveröffentlichung (Fotos, Videos, Reels, Karussells)
• Medien-Insights und Analysen
• Kommentar- und Erwähnungsverwaltung
• Direktnachrichten (über Instagram Graph API + Messenger Platform)
• Hashtag- und Erwählungsverfolgung
• Story-Verwaltung
• Shopping- und Produkt-Tags

Hauptmerkmale

Kontenanforderungen

Übersicht über die API-Architektur

Instagram verwendet die Struktur der Facebook Graph API:

https://graph.facebook.com/v18.0/

API-Versionen im Vergleich

Facebook veröffentlicht vierteljährlich neue Versionen. Zielen Sie immer auf die neueste stabile Version ab.

Erste Schritte: Authentifizierung einrichten

Schritt 1: Facebook-Entwicklerkonto erstellen

Bevor Sie auf die API zugreifen:

1. Besuchen Sie das Facebook Developers Portal
2. Melden Sie sich mit einem Facebook-Konto an
3. Erstellen Sie eine Facebook-App (Typ: Business)
4. Fügen Sie das Instagram Graph API-Produkt hinzu

Schritt 2: Instagram Business-Konto verknüpfen

Verbinden Sie Instagram mit Ihrer Facebook-Seite:

1. Gehen Sie zu den Facebook-Seiteneinstellungen > Instagram
2. Klicken Sie auf Konto verbinden
3. Melden Sie sich bei Instagram an und autorisieren Sie die Verbindung
4. Bestätigen Sie, dass das Instagram Business-Konto verknüpft ist

Hinweis: Persönliche Instagram-Konten können die Graph API nicht verwenden. Konvertieren Sie das Konto in den Instagram-Einstellungen in ein Business- oder Creator-Konto.

Schritt 3: Zugriffstoken abrufen

Benutzer-Zugriffstoken generieren:

const FB_APP_ID = process.env.FB_APP_ID;
const FB_APP_SECRET = process.env.FB_APP_SECRET;
const FB_REDIRECT_URI = process.env.FB_REDIRECT_URI;

// Build authorization URL
const getAuthUrl = (state) => {
  const params = new URLSearchParams({
    client_id: FB_APP_ID,
    redirect_uri: FB_REDIRECT_URI,
    scope: 'instagram_basic,instagram_content_publish,instagram_manage_comments,instagram_manage_insights,pages_read_engagement',
    state: state
  });

  return `https://www.facebook.com/v18.0/dialog/oauth?${params.toString()}`;
};

Erforderliche Berechtigungen

Schritt 4: Token gegen langlebiges Token tauschen

Kurzlebige Token verfallen nach 1 Stunde. Tauschen Sie sie gegen ein langlebiges Token (60 Tage) aus:

const exchangeForLongLivedToken = async (shortLivedToken) => {
  const response = await fetch(
    `https://graph.facebook.com/v18.0/oauth/access_token?` +
    `grant_type=fb_exchange_token&` +
    `client_id=${FB_APP_ID}&` +
    `client_secret=${FB_APP_SECRET}&` +
    `fb_exchange_token=${shortLivedToken}`
  );

  const data = await response.json();
  return data;
};

// Usage
const longLivedToken = await exchangeForLongLivedToken(shortLivedToken);
console.log(`Token expires: ${new Date(longLivedToken.expires_at * 1000)}`);

Schritt 5: Instagram Business-Konto-ID abrufen

Verbundenes Instagram-Konto abrufen:

const getInstagramAccountId = async (pageId, accessToken) => {
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${pageId}?fields=instagram_business_account&access_token=${accessToken}`
  );

  const data = await response.json();
  return data.instagram_business_account.id;
};

// Usage
const igAccountId = await getInstagramAccountId('12345678', accessToken);
console.log(`Instagram Account ID: ${igAccountId}`);

Schritt 6: Authentifizierte API-Aufrufe tätigen

Wiederverwendbaren API-Client erstellen:

const IG_BASE_URL = 'https://graph.facebook.com/v18.0';

const instagramRequest = async (endpoint, params = {}) => {
  const url = new URL(`${IG_BASE_URL}${endpoint}`);
  url.searchParams.append('access_token', process.env.INSTAGRAM_ACCESS_TOKEN);

  Object.entries(params).forEach(([key, value]) => {
    url.searchParams.append(key, value);
  });

  const response = await fetch(url.toString());

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Instagram API Error: ${error.error.message}`);
  }

  return response.json();
};

// Usage
const account = await instagramRequest(`/me`);
console.log(`Instagram Account: ${account.username}`);

Inhaltsveröffentlichung

Ein Foto veröffentlichen

Ein Foto auf Instagram posten:

const publishPhoto = async (igAccountId, photoData) => {
  // Step 1: Create media container
  const containerResponse = await instagramRequest(`/${igAccountId}/media`, {
    method: 'POST',
    image_url: photoData.imageUrl,
    caption: photoData.caption,
    location_id: photoData.locationId, // Optional
    is_carousel_item: 'false'
  });

  const creationId = containerResponse.id;

  // Step 2: Publish the media
  const publishResponse = await instagramRequest(`/${igAccountId}/media_publish`, {
    method: 'POST',
    creation_id: creationId
  });

  return publishResponse;
};

// Usage
const post = await publishPhoto({
  igAccountId: '17841400000000000',
  imageUrl: 'https://example.com/image.jpg',
  caption: 'Excited to announce our new product! 🚀 #launch #innovation',
  locationId: '123456789' // Optional
});

console.log(`Published media ID: ${post.id}`);

Ein Video veröffentlichen

Ein Video auf Instagram posten:

const publishVideo = async (igAccountId, videoData) => {
  // Step 1: Create media container
  const containerResponse = await instagramRequest(`/${igAccountId}/media`, {
    method: 'POST',
    video_url: videoData.videoUrl,
    cover_url: videoData.coverUrl, // Optional thumbnail
    caption: videoData.caption,
    media_type: 'REELS', // or 'VIDEO' for feed
    share_to_feed: 'true' // For reels
  });

  const creationId = containerResponse.id;

  // Wait for video processing (poll until status is EXPIRED or FINISHED)
  await waitForVideoProcessing(creationId);

  // Step 2: Publish the media
  const publishResponse = await instagramRequest(`/${igAccountId}/media_publish`, {
    method: 'POST',
    creation_id: creationId
  });

  return publishResponse;
};

const waitForVideoProcessing = async (creationId, maxAttempts = 30) => {
  for (let i = 0; i < maxAttempts; i++) {
    const status = await instagramRequest(`/${creationId}`);

    if (status.status_code === 'FINISHED') {
      return true;
    } else if (status.status_code === 'EXPIRED') {
      throw new Error('Video processing expired');
    }

    await new Promise(resolve => setTimeout(resolve, 2000));
  }

  throw new Error('Video processing timeout');
};

Ein Karussell veröffentlichen (mehrere Bilder/Videos)

Mehrere Medienelemente in einem Post veröffentlichen:

const publishCarousel = async (igAccountId, carouselData) => {
  const children = [];

  // Step 1: Create each carousel item
  for (const item of carouselData.items) {
    const containerResponse = await instagramRequest(`/${igAccountId}/media`, {
      method: 'POST',
      [item.type === 'video' ? 'video_url' : 'image_url']: item.url,
      caption: item.caption || '',
      is_carousel_item: 'true'
    });

    children.push(containerResponse.id);
  }

  // Step 2: Create carousel container with children
  const carouselContainerResponse = await instagramRequest(`/${igAccountId}/media`, {
    method: 'POST',
    media_type: 'CAROUSEL',
    children: children.join(','),
    caption: carouselData.caption
  });

  const creationId = carouselContainerResponse.id;

  // Step 3: Publish the carousel
  const publishResponse = await instagramRequest(`/${igAccountId}/media_publish`, {
    method: 'POST',
    creation_id: creationId
  });

  return publishResponse;
};

// Usage
const carousel = await publishCarousel('17841400000000000', {
  caption: 'Product showcase 2026',
  items: [
    { type: 'image', url: 'https://example.com/img1.jpg', caption: 'Product 1' },
    { type: 'image', url: 'https://example.com/img2.jpg', caption: 'Product 2' },
    { type: 'video', url: 'https://example.com/vid1.mp4', caption: 'Demo' }
  ]
});

Medientypen

Medien und Insights abrufen

Benutzermedien abrufen

Veröffentlichte Medien abrufen:

const getUserMedia = async (igAccountId, limit = 25) => {
  const response = await instagramRequest(`/${igAccountId}/media`, {
    fields: 'id,caption,media_type,media_url,permalink,timestamp,like_count,comments_count',
    limit: limit.toString()
  });

  return response;
};

// Usage
const media = await getUserMedia('17841400000000000');
media.data.forEach(item => {
  console.log(`${item.media_type}: ${item.caption}`);
  console.log(`Likes: ${item.like_count}, Comments: ${item.comments_count}`);
  console.log(`URL: ${item.permalink}`);
});

Medien-Insights abrufen

Analysen für bestimmte Medien abrufen:

const getMediaInsights = async (mediaId) => {
  const response = await instagramRequest(`/${mediaId}/insights`, {
    fields: 'impressions,reach,engagement,saved,video_views,profile_visits,follows'
  });

  return response;
};

// Usage
const insights = await getMediaInsights('17890000000000000');
insights.data.forEach(metric => {
  console.log(`${metric.name}: ${metric.values[0].value}`);
});

Verfügbare Insights-Metriken

Konto-Insights abrufen

Aggregierte Kontoanalysen abrufen:

const getAccountInsights = async (igAccountId, metricNames, since = null, until = null) => {
  const params = {
    metric: metricNames.join(','),
    period: 'day'
  };

  if (since) params.since = since;
  if (until) params.until = until;

  const response = await instagramRequest(`/${igAccountId}/insights`, params);

  return response;
};

// Usage - Get last 30 days of metrics
const accountInsights = await getAccountInsights(
  '17841400000000000',
  ['impressions', 'reach', 'profile_views', 'email_contacts', 'website_clicks'],
  '2026-02-23',
  '2026-03-25'
);

accountInsights.data.forEach(metric => {
  console.log(`${metric.name}:`);
  metric.values.forEach(value => {
    console.log(`  ${value.end_time}: ${value.value}`);
  });
});

Metriken auf Kontoebene

Kommentarverwaltung

Kommentare abrufen

Kommentare zu Medien abrufen:

const getMediaComments = async (mediaId, limit = 50) => {
  const response = await instagramRequest(`/${mediaId}/comments`, {
    fields: 'id,text,timestamp,username,hidden',
    limit: limit.toString()
  });

  return response;
};

// Usage
const comments = await getMediaComments('17890000000000000');
comments.data.forEach(comment => {
  console.log(`@${comment.username}: ${comment.text}`);
  console.log(`Hidden: ${comment.hidden}`);
});

Auf Kommentare antworten

Antwort auf einen Kommentar posten:

const replyToComment = async (mediaId, commentId, replyText) => {
  const response = await instagramRequest(`/${mediaId}/comments`, {
    method: 'POST',
    response_to: commentId,
    message: replyText
  });

  return response;
};

// Usage
const reply = await replyToComment(
  '17890000000000000',
  '17900000000000000',
  'Thank you for your interest! Check your DM for details.'
);
console.log(`Reply posted: ${reply.id}`);

Kommentare ausblenden

Unangemessene Kommentare ausblenden:

const hideComment = async (commentId) => {
  const response = await instagramRequest(`/${commentId}`, {
    method: 'POST',
    hide: 'true'
  });

  return response;
};

// Usage
await hideComment('17900000000000000');
console.log('Comment hidden');

Kommentare löschen

Spam oder unangemessene Kommentare entfernen:

const deleteComment = async (commentId) => {
  await instagramRequest(`/${commentId}`, {
    method: 'DELETE'
  });

  console.log('Comment deleted');
};

Webhooks

Webhooks konfigurieren

Webhooks für Echtzeit-Benachrichtigungen einrichten:

const subscribeToWebhooks = async (appId, pageId, accessToken) => {
  // Subscribe to Instagram events
  const response = await fetch(
    `https://graph.facebook.com/v18.0/${appId}/subscriptions`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        object: 'instagram',
        callback_url: 'https://myapp.com/webhooks/instagram',
        verify_token: process.env.WEBHOOK_VERIFY_TOKEN,
        access_token: accessToken,
        fields: ['comments', 'mentions', 'message_reactions']
      })
    }
  );

  return response.json();
};

Webhooks verarbeiten

const express = require('express');
const app = express();

// Verify webhook subscription
app.get('/webhooks/instagram', (req, res) => {
  const mode = req.query['hub.mode'];
  const token = req.query['hub.verify_token'];
  const challenge = req.query['hub.challenge'];

  if (mode === 'subscribe' && token === process.env.WEBHOOK_VERIFY_TOKEN) {
    console.log('Webhook verified');
    res.status(200).send(challenge);
  } else {
    res.status(403).send('Verification failed');
  }
});

// Handle webhook events
app.post('/webhooks/instagram', express.json(), async (req, res) => {
  const body = req.body;

  if (body.object !== 'instagram') {
    return res.status(404).send('Not found');
  }

  for (const entry of body.entry) {
    const igId = entry.id;
    const changes = entry.changes;

    for (const change of changes) {
      switch (change.field) {
        case 'comments':
          await handleNewComment(change.value);
          break;
        case 'mentions':
          await handleMention(change.value);
          break;
        case 'message_reactions':
          await handleReaction(change.value);
          break;
      }
    }
  }

  res.status(200).send('OK');
});

async function handleNewComment(data) {
  console.log(`New comment on media ${data.media_id}`);
  console.log(`From: ${data.from_id}`);
  console.log(`Text: ${data.text}`);

  // Auto-reply or moderate
  if (isSpam(data.text)) {
    await hideComment(data.id);
  }
}

Webhook-Felder

Ratenbegrenzung

Ratenbegrenzungen verstehen

Die Instagram Graph API erzwingt:

• 200 Aufrufe pro Stunde pro App (geteilt auf alle Benutzer)
• Business Discovery: 200 Aufrufe pro Stunde pro Benutzer
• Inhaltsveröffentlichung: Begrenzt nach Aktionstyp

Das Überschreiten der Limits führt zu HTTP 400 mit Fehler-Subcode 613.

Best Practices für Ratenbegrenzungen

1. Antworten cachen - Nicht unveränderte Daten erneut abrufen
2. Anfragen bündeln - Feldexpansion nutzen, um Aufrufe zu reduzieren
3. Webhooks verwenden - Echtzeit-Updates statt Polling
4. Backoff implementieren - Exponentieller Backoff bei 429-Fehlern

const makeRateLimitedRequest = async (endpoint, params = {}, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await instagramRequest(endpoint, params);
      return response;
    } catch (error) {
      if (error.message.includes('429') && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
};

Häufige Probleme beheben

Problem: OAuth-Token abgelaufen

Symptome: Fehlermeldungen "Ungültiger OAuth-Zugriffstoken".

Lösungen:

1. Token-Refresh vor Ablauf der 60-Tage-Frist implementieren
2. Ablaufdatum des Tokens speichern und vor Ablauf benachrichtigen
3. Benutzer erneut authentifizieren, wenn das Token abgelaufen ist

Problem: Medienveröffentlichung schlägt fehl

Symptome: Veröffentlichung gibt einen Fehler zurück.

Lösungen:

1. Überprüfen Sie, ob die Bild-URL öffentlich zugänglich ist (keine Authentifizierung erforderlich)
2. Überprüfen Sie das Bildformat (JPEG, PNG) und die Größe (<8 MB)
3. Stellen Sie sicher, dass das Video im MP4-Format ist, <1 GB und <90 Sekunden lang ist
4. Warten Sie die Videoverarbeitung ab, bevor Sie veröffentlichen

Problem: Insights nicht verfügbar

Symptome: Insights API gibt leere Daten zurück.

Lösungen:

1. Überprüfen Sie, ob das Konto Business oder Creator ist (nicht Persönlich)
2. Warten Sie 24-48 Stunden, bis die Insights gefüllt sind
3. Stellen Sie sicher, dass das Konto ausreichend aktiv ist

Checkliste für die Produktionsbereitstellung

Vor der Live-Schaltung:

• [ ] Alle Testkonten in Business/Creator umwandeln
• [ ] OAuth 2.0 mit langlebigen Tokens implementieren
• [ ] Tokens sicher und verschlüsselt speichern
• [ ] Automatische Token-Aktualisierung implementieren
• [ ] Webhook-Endpunkte mit HTTPS einrichten
• [ ] Ratenbegrenzung und Anfragenwarteschlange hinzufügen
• [ ] Umfassende Fehlerbehandlung implementieren
• [ ] Protokollierung für alle API-Aufrufe hinzufügen
• [ ] Workflows für die Inhaltsmoderation erstellen
• [ ] Mit mehreren Kontotypen testen

Anwendungsfälle aus der Praxis

Tool zur Social-Media-Planung

Eine Marketingplattform automatisiert die Veröffentlichung:

• Herausforderung: Manuelles Posten über 50+ Kundenkonten hinweg
• Lösung: Geplante Veröffentlichung über die Instagram API
• Ergebnis: 80 % Zeitersparnis, konsistenter Veröffentlichungsplan

Schlüsselimplementierung:

• Inhaltskalender mit Drag-and-Drop-Planung
• Automatische Veröffentlichung von Fotos, Videos, Karussells
• Hashtag-Vorschläge basierend auf dem Inhalt

Kundendienst-Automatisierung

Eine E-Commerce-Marke automatisiert die Beantwortung von Kommentaren:

• Herausforderung: Langsame Reaktion auf Kundenanfragen
• Lösung: Automatische Beantwortung häufiger Fragen über Webhook
• Ergebnis: Durchschnittliche Antwortzeit von 5 Minuten, 90 % Zufriedenheit

Schlüsselimplementierung:

• Stichworterkennung (Preis, Verfügbarkeit, Versand)
• Automatische Antwort mit Produktlinks
• Komplexe Anfragen an menschliche Agenten eskalieren

Fazit

Die Instagram Graph API bietet umfassenden Zugriff auf die Funktionen von Instagram Business- und Creator-Konten. Die wichtigsten Erkenntnisse:

• Facebook Login OAuth 2.0-Authentifizierung mit 60-Tage-Tokens
• Die Inhaltsveröffentlichung unterstützt Fotos, Videos, Reels, Karussells
• Die Insights API liefert Engagement-, Reichweiten- und demografische Daten
• Webhooks ermöglichen die Echtzeitüberwachung von Kommentaren und Erwähnungen
• Die Ratenbegrenzung von 200 Aufrufen/Stunde pro App erfordert sorgfältiges Management
• Apidog optimiert das API-Testen und die Teamzusammenarbeit

FAQ-Bereich

Wie erhalte ich Zugang zur Instagram API?

Erstellen Sie ein Facebook-Entwicklerkonto, erstellen Sie eine Business-App, fügen Sie das Instagram Graph API-Produkt hinzu und authentifizieren Sie sich über Facebook Login mit den erforderlichen Berechtigungen.

Kann ich automatisch auf Instagram posten?

Ja, verwenden Sie die Content Publishing API, um Fotos, Videos, Reels und Karussells auf Business- und Creator-Konten zu veröffentlichen.

Welche Arten von Instagram-Konten unterstützen die API?

Nur Business- und Creator-Konten haben vollen API-Zugriff. Persönliche Konten haben begrenzten oder keinen API-Zugriff.

Wie rufe ich Kommentare von Instagram ab?

Verwenden Sie den Kommentare-Endpunkt (/{media-id}/comments), um Kommentare zu bestimmten Medien abzurufen. Webhooks bieten Echtzeit-Benachrichtigungen.

Was sind die Ratenbegrenzungen von Instagram?

Die Instagram Graph API erlaubt 200 Aufrufe pro Stunde pro App. Einige Endpunkte haben zusätzliche Pro-Benutzer-Limits.

Kann ich Stories über die API veröffentlichen?

Ja, Stories können mit demselben Veröffentlichungsfluss wie Feed-Posts veröffentlicht werden.

Wie greife ich auf Instagram Insights zu?

Fordern Sie die Berechtigung instagram_manage_insights während des OAuth-Prozesses an. Verwenden Sie den Insights-Endpunkt, um Metriken für Medien und Konten abzurufen.

Kann ich automatisch auf Kommentare antworten?

Ja, verwenden Sie die Kommentare-API, um Antworten zu posten. Viele Marken nutzen dies für automatisierte Kundendienstantworten.