Blog

Hootsuite API Nutzung: Eine Anleitung

Ashley Innocent

Ashley Innocent

25 March 2026

Hootsuite API Nutzung: Eine Anleitung

Apidog für Unternehmen

On-Premises Bereitstellung

SSO & RBAC

SOC 2 konform

Apidog Enterprise entdecken

TL;DR

Die Hootsuite API ermöglicht Entwicklern die programmatische Integration in Social-Media-Management-Workflows. Sie verwendet OAuth 2.0-Authentifizierung, RESTful-Endpunkte für Profile, Beiträge, Analysen und Teammanagement, mit Ratenbegrenzungen von 50-200 Anfragen pro Minute, je nach Plan. Dieser Leitfaden behandelt die Einrichtung der Authentifizierung, die Beitragsplanung, den Abruf von Analysen, das Teammanagement und Strategien für die Produktionsintegration.

Hinweis: Hootsuite hat seine öffentliche API ab 2024 eingestellt. Dieser Leitfaden behandelt alternative Ansätze, einschließlich Hootsuite-Partnerintegrationen, Webhooks und APIs von Drittanbietern für das Social-Media-Management, die ähnliche Funktionen bieten.

Einleitung

Hootsuite verwaltet über 30 Millionen Social-Media-Konten für mehr als 200.000 Unternehmen in über 175 Ländern. Für Entwickler, die Social-Media-Tools, Marketingplattformen oder Analyse-Dashboards erstellen, ist die Integration von Social-Media-APIs unerlässlich, um dieses riesige Geschäftspublikum zu erreichen.

Hier ist die Realität: Social-Media-Manager, die mehr als 20 Konten betreuen, verlieren wöchentlich 25-35 Stunden durch manuelles Posten, Engagement-Tracking und Berichtserstellung. Eine solide Social-Media-API-Integration automatisiert die Inhaltsverteilung, das Engagement-Monitoring, die Stimmungsanalyse und die Leistungsberichterstattung.

button

Hootsuite API Status und Alternativen

Aktuelle API-Situation

Ab 2024 hat Hootsuite seine öffentliche API eingestellt. Integrationsoptionen:

Ansatz Beschreibung Am besten geeignet für
Native Plattform-APIs Direkte Integration mit Facebook, Twitter, LinkedIn usw. Volle Kontrolle, kundenspezifische Lösungen
Audiense Hootsuite-eigene Zielgruppenanalyse Zielgruppenanalyse
HeyOrca Social Media Scheduling API Inhaltskalender
Buffer API Social Media Management Kleine Teams
Sprout Social API Enterprise Social Management Große Organisationen
Agorapulse API Social Media CRM Community-Management

Empfohlener Ansatz: Native Plattform-APIs

Für die meisten Anwendungsfälle bietet die direkte Integration mit sozialen Plattformen die größte Flexibilität:

Plattform API-Name Hauptfunktionen
Facebook/Instagram Graph API Beiträge, Einblicke, Kommentare
Twitter/X API v2 Tweets, Analysen, Streams
LinkedIn Marketing API Beiträge, Unternehmensseiten, Anzeigen
Pinterest API v5 Pins, Boards, Analysen
TikTok Display API Videos, Benutzerinformationen
YouTube Data API Videos, Playlists, Analysen

Erste Schritte: Multi-Plattform-Authentifizierung

Schritt 1: Entwickler-Apps registrieren

Erstellen Sie Entwicklerkonten für jede Plattform:

// Zugangsdaten sicher speichern
const SOCIAL_CREDENTIALS = {
  facebook: {
    appId: process.env.FB_APP_ID,
    appSecret: process.env.FB_APP_SECRET,
    redirectUri: process.env.FB_REDIRECT_URI
  },
  twitter: {
    apiKey: process.env.TWITTER_API_KEY,
    apiSecret: process.env.TWITTER_API_SECRET,
    redirectUri: process.env.TWITTER_REDIRECT_URI
  },
  linkedin: {
    clientId: process.env.LINKEDIN_CLIENT_ID,
    clientSecret: process.env.LINKEDIN_CLIENT_SECRET,
    redirectUri: process.env.LINKEDIN_REDIRECT_URI
  },
  instagram: {
    appId: process.env.FB_APP_ID, // Verwendet Facebook Login
    appSecret: process.env.FB_APP_SECRET
  }
};

Schritt 2: OAuth 2.0-Flow implementieren

Vereinheitlichter OAuth-Handler für mehrere Plattformen:

const getAuthUrl = (platform, state) => {
  const configs = {
    facebook: {
      url: 'https://www.facebook.com/v18.0/dialog/oauth',
      params: {
        client_id: SOCIAL_CREDENTIALS.facebook.appId,
        redirect_uri: SOCIAL_CREDENTIALS.facebook.redirectUri,
        scope: 'pages_manage_posts,pages_read_engagement,instagram_basic,instagram_content_publish',
        state
      }
    },
    twitter: {
      url: 'https://twitter.com/i/oauth2/authorize',
      params: {
        client_id: SOCIAL_CREDENTIALS.twitter.apiKey,
        redirect_uri: SOCIAL_CREDENTIALS.twitter.redirectUri,
        scope: 'tweet.read tweet.write users.read offline.access',
        state,
        response_type: 'code'
      }
    },
    linkedin: {
      url: 'https://www.linkedin.com/oauth/v2/authorization',
      params: {
        client_id: SOCIAL_CREDENTIALS.linkedin.clientId,
        redirect_uri: SOCIAL_CREDENTIALS.linkedin.redirectUri,
        scope: 'w_member_social r_basicprofile',
        state,
        response_type: 'code'
      }
    }
  };

  const config = configs[platform];
  const params = new URLSearchParams(config.params);
  return `${config.url}?${params.toString()}`;
};

// OAuth-Callback verarbeiten
const handleOAuthCallback = async (platform, code) => {
  const tokenEndpoints = {
    facebook: 'https://graph.facebook.com/v18.0/oauth/access_token',
    twitter: 'https://api.twitter.com/2/oauth2/token',
    linkedin: 'https://www.linkedin.com/oauth/v2/accessToken'
  };

  const response = await fetch(tokenEndpoints[platform], {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams({
      client_id: SOCIAL_CREDENTIALS[platform].apiKey || SOCIAL_CREDENTIALS[platform].appId || SOCIAL_CREDENTIALS[platform].clientId,
      client_secret: SOCIAL_CREDENTIALS[platform].appSecret || SOCIAL_CREDENTIALS[platform].apiSecret,
      redirect_uri: SOCIAL_CREDENTIALS[platform].redirectUri,
      code,
      grant_type: 'authorization_code'
    })
  });

  return response.json();
};

Schritt 3: Tokens sicher speichern

// Datenbankschema für soziale Tokens
const SocialToken = {
  userId: 'user_123',
  platform: 'facebook',
  accessToken: 'encrypted_token_here',
  refreshToken: 'encrypted_refresh_token',
  tokenExpiry: Date.now() + 5183999, // 60 Tage
  scopes: ['pages_manage_posts', 'pages_read_engagement'],
  pageId: 'page_456', // Für Facebook/Instagram
  pageName: 'Meine Unternehmensseite'
};

Beitragsplanung und -veröffentlichung

Einen Multi-Plattform-Beitrag erstellen

Gleichzeitig auf mehreren Plattformen veröffentlichen:

const createSocialPost = async (postData) => {
  const results = {};

  // Facebook Seitenbeitrag
  if (postData.platforms.includes('facebook')) {
    results.facebook = await postToFacebook({
      pageId: postData.facebookPageId,
      message: postData.message,
      link: postData.link,
      photo: postData.photo
    });
  }

  // Twitter Beitrag
  if (postData.platforms.includes('twitter')) {
    results.twitter = await postToTwitter({
      text: postData.message,
      media: postData.photo
    });
  }

  // LinkedIn Beitrag
  if (postData.platforms.includes('linkedin')) {
    results.linkedin = await postToLinkedIn({
      authorUrn: postData.linkedinAuthorUrn,
      text: postData.message,
      contentUrl: postData.link
    });
  }

  // Instagram Beitrag
  if (postData.platforms.includes('instagram')) {
    results.instagram = await postToInstagram({
      igAccountId: postData.igAccountId,
      imageUrl: postData.photo,
      caption: postData.message
    });
  }

  return results;
};

// Facebook-Posting
const postToFacebook = async (postData) => {
  const token = await getFacebookPageToken(postData.pageId);

  const params = new URLSearchParams({
    message: postData.message,
    access_token: token
  });

  if (postData.link) {
    params.append('link', postData.link);
  }

  if (postData.photo) {
    params.append('photo', postData.photo);
  }

  const response = await fetch(
    `https://graph.facebook.com/v18.0/${postData.pageId}/feed?${params.toString()}`,
    { method: 'POST' }
  );

  return response.json();
};

// Twitter-Posting
const postToTwitter = async (postData) => {
  const token = await getTwitterToken();

  let mediaIds = [];
  if (postData.media) {
    // Medien zuerst hochladen
    const mediaUpload = await uploadTwitterMedia(postData.media, token);
    mediaIds = [mediaUpload.media_id_string];
  }

  const response = await fetch('https://api.twitter.com/2/tweets', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: postData.text,
      media: mediaIds.length > 0 ? { media_ids: mediaIds } : undefined
    })
  });

  return response.json();
};

// LinkedIn-Posting
const postToLinkedIn = async (postData) => {
  const token = await getLinkedInToken();

  const post = {
    author: postData.authorUrn,
    lifecycleState: 'PUBLISHED',
    specificContent: {
      'com.linkedin.ugc.ShareContent': {
        shareCommentary: {
          text: postData.text
        },
        shareMediaCategory: postData.contentUrl ? 'ARTICLE' : 'NONE',
        media: postData.contentUrl ? [{
          status: 'READY',
          media: postData.contentUrn,
          description: { text: postData.text }
        }] : []
      }
    },
    visibility: {
      'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'
    }
  };

  const response = await fetch('https://api.linkedin.com/v2/ugcPosts', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
      'X-Restli-Protocol-Version': '2.0.0'
    },
    body: JSON.stringify(post)
  });

  return response.json();
};

// Instagram-Posting
const postToInstagram = async (postData) => {
  const token = await getInstagramToken();

  // Schritt 1: Mediencontainer erstellen
  const containerResponse = await fetch(
    `https://graph.facebook.com/v18.0/${postData.igAccountId}/media`,
    {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${token}` },
      body: JSON.stringify({
        image_url: postData.imageUrl,
        caption: postData.caption
      })
    }
  );

  const container = await containerResponse.json();

  // Schritt 2: Veröffentlichen
  const publishResponse = await fetch(
    `https://graph.facebook.com/v18.0/${postData.igAccountId}/media_publish`,
    {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${token}` },
      body: JSON.stringify({ creation_id: container.id })
    }
  );

  return publishResponse.json();
};

Beiträge planen

Beitragsplanung implementieren:

const schedulePost = async (postData, scheduledTime) => {
  // In der Datenbank zur späteren Ausführung speichern
  const scheduledPost = await db.scheduledPosts.create({
    message: postData.message,
    platforms: postData.platforms,
    scheduledTime: scheduledTime,
    status: 'pending',
    media: postData.media,
    link: postData.link
  });

  // Job-Warteschlange einrichten
  await jobQueue.add('publish-social-post', {
    postId: scheduledPost.id
  }, {
    delay: scheduledTime - Date.now()
  });

  return scheduledPost;
};

// Job-Prozessor
jobQueue.process('publish-social-post', async (job) => {
  const post = await db.scheduledPosts.findById(job.data.postId);

  try {
    const result = await createSocialPost(post);

    await db.scheduledPosts.update(post.id, {
      status: 'published',
      publishedAt: new Date(),
      results: result
    });

    return result;
  } catch (error) {
    await db.scheduledPosts.update(post.id, {
      status: 'failed',
      error: error.message
    });

    throw error;
  }
});

Analysen und Berichterstattung

Abrufen von plattformübergreifenden Analysen

Metriken von allen Plattformen aggregieren:

const getSocialAnalytics = async (accountId, dateRange) => {
  const analytics = {
    facebook: await getFacebookAnalytics(accountId.facebook, dateRange),
    twitter: await getTwitterAnalytics(accountId.twitter, dateRange),
    linkedin: await getLinkedInAnalytics(accountId.linkedin, dateRange),
    instagram: await getInstagramAnalytics(accountId.instagram, dateRange)
  };

  // Metriken aggregieren
  const totals = {
    impressions: sum(analytics, 'impressions'),
    engagement: sum(analytics, 'engagement'),
    clicks: sum(analytics, 'clicks'),
    shares: sum(analytics, 'shares'),
    comments: sum(analytics, 'comments'),
    newFollowers: sum(analytics, 'newFollowers')
  };

  return { analytics, totals };
};

// Facebook Insights
const getFacebookAnalytics = async (pageId, dateRange) => {
  const token = await getFacebookPageToken(pageId);

  const metrics = [
    'page_impressions_unique',
    'page_engaged_users',
    'page_post_engagements',
    'page_clicks',
    'page_fan_adds'
  ];

  const params = new URLSearchParams({
    metric: metrics.join(','),
    since: dateRange.from,
    until: dateRange.until,
    access_token: token
  });

  const response = await fetch(
    `https://graph.facebook.com/v18.0/${pageId}/insights?${params.toString()}`
  );

  return response.json();
};

// Twitter-Analysen
const getTwitterAnalytics = async (userId, dateRange) => {
  const token = await getTwitterToken();

  const response = await fetch(
    `https://api.twitter.com/2/users/${userId}/metrics/private`,
    {
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return response.json();
};

// LinkedIn-Analysen
const getLinkedInAnalytics = async (organizationId, dateRange) => {
  const token = await getLinkedInToken();

  const response = await fetch(
    `https://api.linkedin.com/v2/organizationalEntityFollowerStatistics?q=organizationalEntity&organizationalEntity=${organizationId}`,
    {
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return response.json();
};

// Instagram Insights
const getInstagramAnalytics = async (igAccountId, dateRange) => {
  const token = await getInstagramToken();

  const metrics = [
    'impressions',
    'reach',
    'engagement',
    'profile_views',
    'follower_count'
  ];

  const params = new URLSearchParams({
    metric: metrics.join(','),
    period: 'day',
    since: dateRange.from,
    until: dateRange.until
  });

  const response = await fetch(
    `https://graph.facebook.com/v18.0/${igAccountId}/insights?${params.toString()}`,
    {
      headers: { 'Authorization': `Bearer ${token}` }
    }
  );

  return response.json();
};

function sum(analytics, metric) {
  return Object.values(analytics).reduce((total, platform) => {
    return total + (platform.data?.[metric] || 0);
  }, 0);
}

Teammanagement

Rollenbasierte Zugriffskontrolle

const TEAM_ROLES = {
  ADMIN: 'admin',
  MANAGER: 'manager',
  CONTRIBUTOR: 'contributor',
  VIEWER: 'viewer'
};

const ROLE_PERMISSIONS = {
  [TEAM_ROLES.ADMIN]: ['create', 'read', 'update', 'delete', 'manage_team', 'billing'],
  [TEAM_ROLES.MANAGER]: ['create', 'read', 'update', 'approve_posts'],
  [TEAM_ROLES.CONTRIBUTOR]: ['create', 'read'],
  [TEAM_ROLES.VIEWER]: ['read']
};

const checkPermission = (userRole, requiredPermission) => {
  const permissions = ROLE_PERMISSIONS[userRole] || [];
  return permissions.includes(requiredPermission);
};

Ratenbegrenzung

Plattform-Ratenbegrenzungen

Plattform Limit Fenster
Facebook Graph 200 Anrufe Pro Stunde pro Benutzer
Twitter API v2 300 Tweets Pro 15 Min.
LinkedIn 100-500 Anrufe Pro Tag
Instagram 200 Anrufe Pro Stunde

Implementierung der Ratenbegrenzungsbehandlung

class SocialMediaRateLimiter {
  constructor() {
    this.limits = {
      facebook: { limit: 200, window: 3600000 },
      twitter: { limit: 300, window: 900000 },
      linkedin: { limit: 500, window: 86400000 },
      instagram: { limit: 200, window: 3600000 }
    };
    this.counters = {};
  }

  async request(platform, endpoint, options) {
    await this.waitForCapacity(platform);

    const response = await fetch(endpoint, options);
    this.incrementCounter(platform);

    return response;
  }

  async waitForCapacity(platform) {
    const limit = this.limits[platform];
    const counter = this.counters[platform] || { count: 0, resetTime: Date.now() };

    if (Date.now() > counter.resetTime + limit.window) {
      counter.count = 0;
      counter.resetTime = Date.now();
    }

    if (counter.count >= limit.limit) {
      const waitTime = counter.resetTime + limit.window - Date.now();
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }

    this.counters[platform] = counter;
  }

  incrementCounter(platform) {
    if (!this.counters[platform]) {
      this.counters[platform] = { count: 0, resetTime: Date.now() };
    }
    this.counters[platform].count++;
  }
}

Checkliste für die Produktionsbereitstellung

Vor dem Go-Live:

Praktische Anwendungsfälle

Social Media Dashboard

Eine Marketingagentur erstellt ein einheitliches Dashboard:

Automatisierte Inhaltsverteilung

Ein Verlag automatisiert das Teilen von Artikeln:

Fazit

Obwohl die öffentliche API von Hootsuite eingestellt wurde, bieten native Plattform-APIs umfassende Social-Media-Management-Funktionen. Wichtige Erkenntnisse:

button

FAQ-Bereich

Hat Hootsuite noch eine API?

Hootsuite hat seine öffentliche API 2024 eingestellt. Verwenden Sie native Plattform-APIs oder alternative Management-Plattformen wie Buffer, Sprout Social oder Agorapulse.

Wie poste ich gleichzeitig auf mehreren Plattformen?

Implementieren Sie OAuth für jede Plattform und erstellen Sie eine einheitliche Posting-Funktion, die die API jeder Plattform parallel aufruft.

Was sind die Ratenbegrenzungen für Social Media APIs?

Limits variieren: Facebook (200/Stunde), Twitter (300/15min), LinkedIn (100-500/Tag), Instagram (200/Stunde).

Wie plane ich Beiträge?

Speichern Sie Beiträge in einer Datenbank mit einer `scheduled_time` und verwenden Sie dann eine Job-Warteschlange (Bull, Agenda), um sie zur geplanten Zeit zu veröffentlichen.

Kann ich Analysen von allen Plattformen erhalten?

Ja, jede Plattform bietet Analyse-APIs. Aggregieren Sie Daten für plattformübergreifende Berichte.

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenHerunterladen