Blog2Social API (1.0.0)

One API 25+ Social Platforms

Connect, manage and publish content across 25+ social media, blogging and community platforms through a single integration.

Instead of building and maintaining separate integrations for every platform, Blog2Social provides one centralized API for publishing text, links, images and videos at scale.

Whether you are building a SaaS platform, CMS, marketing automation solution, agency dashboard, e-commerce platform or enterprise application, Blog2Social helps you automate social media publishing while reducing development effort and maintenance costs.

Key Benefits

• One integration for 25+ social media and publishing platforms
• Publish content across multiple networks simultaneously
• Connect profiles, pages and groups through one API
• Support for text, links, images and videos
• Retrieve social media insights and performance metrics
• Automate publishing workflows and content distribution
• Scale from a single user to thousands of connected accounts

Schedule, publish and manage content across social media, blogging, business and community platforms through a single API.

Connect accounts, publish content, upload media, retrieve insights and automate social media distribution from one centralized interface.

Platform	Post Types	Media
Facebook	Posts, Reels	Links, Images, Videos
X	Posts	Links, Images, Videos
LinkedIn	Posts	Links, Images, Videos
Instagram	Posts	Images, Videos
Pinterest	Pins, Boards	Images, Videos
Reddit	Posts, Subreddits	Links, Images
Tumblr	Posts	Links, Images, Videos
Medium	Articles	Images
Telegram	Messages	Links, Images
TikTok	Posts	Images, Videos
YouTube	Videos, Shorts, Playlists	Videos
Vimeo	Videos	Videos
Bluesky	Posts	Links, Images
Threads	Posts	Links, Images, Videos
Mastodon	Posts	Links, Images, Videos
Discord	Messages	Images, Videos
Google Business Profile	Business Posts	Images
VK (VKontakte)	Posts	Links, Images
Xing	Posts	Links, Images
Blogger	Articles	Images
DEV.to	Articles	Images, Videos
Flickr	Media Posts	Images, Videos
Diigo	Bookmarks	Links
Bloglovin	Blog Posts	Images
Torial	Articles	Images
Ravelry	Posts	Images
Instapaper	Saved Content	Links
Band	Posts	Images
HumHub	Posts	Images

The Blog2Social API provides a unified interface for publishing content across social media networks, blogging platforms, business networks, video platforms and community platforms.

---

Platform Features

• Multi-network publishing
• Link, image and video publishing
• Profiles, pages and groups
• Boards, playlists and categories
• Post insights and analytics
• Video upload support
• Automated publishing workflows

---

Get your first social media post published in less than 5 minutes.

The API uses a two-layer authentication model:

service_token = your application
access_token = your user

Think of the service_token as your app key and the access_token as the user's session token.

Most API requests require both tokens.

• A free Blog2Social API account to get started.

Navigate to the My Apps section in your Blog2Social API Console and click Create App.

Once the application has been created, copy the generated service_token and store it securely.

The service_token uniquely identifies your application and is required for all API requests.

POST /user/auth

Request:

{
  "service_token": "YOUR_SERVICE_TOKEN"
}

Response:

{
  "access_token": "USER_ACCESS_TOKEN",
  "refresh_token": "REFRESH_TOKEN"
}

Save the access_token for all future API requests.

POST /network/list

Request:

{
  "service_token": "YOUR_SERVICE_TOKEN",
  "access_token": "USER_ACCESS_TOKEN"
}

Response:

[
  {
    "profile": 1,
    "page": 1,
    "group": 0,
    "network_id": 1,
    "url": "facebook.com",
    "name": "Facebook"
  },
  {
    "profile": 1,
    "page": 0,
    "group": 0,
    "network_id": 45,
    "url": "x.com",
    "name": "X"
  },
  {
    "profile": 1,
    "page": 0,
    "group": 0,
    "network_id": 36,
    "url": "https://www.tiktok",
    "name": "TikTok"
  }
]

Choose the desired network_id from the response.

POST /network/add

Use the network_id from Step 3 and choose the matching network_type_id.

network_type_id values:

• 0 = Profile
• 1 = Page
• 2 = Group

Request:

{
  "service_token": "YOUR_SERVICE_TOKEN",
  "access_token": "USER_ACCESS_TOKEN",
  "network_id": 1,
  "network_type_id": 0,
  "language": "en"
}

Response:

{
  "auth_link": "https://api.blog2social.com/auth/v1/?b2s_session_token=abc123"
}

Redirect the user to the returned auth_link.

POST /user/auth/list

Request:

{
  "service_token": "YOUR_SERVICE_TOKEN",
  "access_token": "USER_ACCESS_TOKEN"
}

Response:

[
  {
    "client_user_network_id": 3241,
    "network_id": 1,
    "type": "profile",
    "display_name": "My Facebook Profile",
    "name": "Facebook"
  }
]

Save the returned client_user_network_id.

Example:

client_user_network_id = 3241

This identifier is required for publishing posts to a connected social media account.

POST /network/post/create

Post Formats:

• 0 = Link
• 1 = Image
• 2 = Video

Request:

{
  "service_token": "YOUR_SERVICE_TOKEN",
  "access_token": "USER_ACCESS_TOKEN",
  "client_user_network_id": 3241,
  "b2s_posts": [
    {
      "client_user_network_id": 3241,
      "title": "My first API post",
      "message": "Hello from the Blog2Social API",
      "postFormat": 0,
      "customUrl": "https://example.com"
    }
  ]
}

Response:

[
  {
    "error": 0,
    "publish_url": "https://facebook.com/post/123456",
    "network_post_id": "123456"
  }
]

If error = 0, the post was published successfully.

• 1.Create an application in the Blog2Social API Console and obtain your service_token.
• 2.Authenticate the user with POST /user/auth.
• 3.Retrieve available social networks with POST /network/list.
• 4.Connect a social network using POST /network/add.
• 5.Retrieve the user's connected accounts with POST /user/auth/list.
• 6.Create and publish a social media post with POST /network/post/create.

You are now ready to publish content through the Blog2Social API.

---

The Blog2Social API returns HTTP status codes for request-level errors and network-specific result objects for publishing results.

When publishing to one or multiple social media networks, always evaluate every returned result object individually. A request can be successful on API level, while one or more networks may still reject or fail the publication.

Publishing endpoints such as /network/post/create return one result object per post or network publication.

Example success:

{
  "error": 0,
  "type": 0,
  "publish_url": "https://example.com/published-post",
  "network_post_id": "123456789",
  "post_id": 1
}

Example failure:

{
  "error": 1,
  "type": 0,
  "b2s_error_code": "TOKEN",
  "extra": {
    "expired": 1
  },
  "post_id": 2
}

Field	Type	Description
error	integer	0 means success, 1 means the publication failed.
b2s_error_code	string	Machine-readable error code for failed publications.
publish_url	string	URL of the published post, if available.
network_post_id	string	ID returned by the social network, if available.
post_id	integer	Internal post reference.
extra.expired	integer	Returned with value 1 when the authorization has expired.

Code	Description	Recommended Action
TOKEN	Authorization expired	Reconnect the social media account.
CONTENT	Content rejected by the network	Adjust the post content and retry.
RIGHT	Missing permissions	Check account/page permissions and reconnect if needed.
LOGIN	Social account disconnected	Reconnect the social media account.
LIMIT	Daily limit reached	Retry later or reduce posting volume.
RATE_LIMIT	Network rate limit reached	Wait before retrying.
NO_DATA	Missing required data	Check required fields and request payload.

When publishing to multiple networks, some publications may succeed while others fail.

Always loop through all response objects and handle failed publications separately.

foreach ($response as $result) {
    if ((int) ($result['error'] ?? 1) === 0) {
        // Published successfully
        continue;
    }

    $error_code = $result['b2s_error_code'] ?? 'DEFAULT';

    // Handle failed publication
}

Retry only when the error is temporary.

Error Code	Retry?	Reason
RATE_LIMIT	Yes, later	The network rate limit may reset.
LIMIT	Yes, later	The daily limit may reset.
TOKEN	No	The account must be reconnected first.
RIGHT	No	Permissions must be fixed first.
CONTENT	No	The content must be changed first.
NO_DATA	No	Required data is missing.

• Always check error for every result object.
• Do not assume that HTTP 200 OK means every network published successfully.
• Store publish_url and network_post_id when available.
• Reconnect accounts when b2s_error_code is TOKEN or extra.expired = 1.
• Log failed result objects for debugging.
• Retry only temporary failures such as RATE_LIMIT or LIMIT.

The API is accessed via HTTP requests to a specific version endpoint URL, in which POST variables contain the information you wish to access. Every endpoint is accessed via an SSL-enabled HTTPS (port 443).

Requests (methods, parameters, etc.) are related to a fixed version number, and every call must contain this version number. Different versions are available at different endpoint URLs. The latest version is version 1.0.0.

The stable HTTP endpoint for the latest version is:

https://api.blog2social.com/rest/v1.0

Previous versions can still be accessed if you use the API version number at the end of the default endpoint. However, these previous versions are no longer supported, so if you find a bug, we are going to ask that you move to the latest version.

---

Test the Blog2Social API directly from your browser and explore available endpoints, request parameters and responses.

Open API Console

---

Blog2Social provides official PHP and Node.js SDKs, comprehensive cURL examples, and REST API access for any programming language. Pick the approach that best fits your workflow.

Use cURL for quick one-off requests, shell scripts, or automation workflows.

# Authenticate a user
curl -X POST https://api.blog2social.com/rest/v1.0/user/auth \
  -H "Content-Type: application/json" \
  -d '{
    "service_token": "YOUR_SERVICE_TOKEN"
  }'

# List available social media networks
curl -X POST https://api.blog2social.com/rest/v1.0/network/list \
  -H "Content-Type: application/json" \
  -d '{
    "service_token": "YOUR_SERVICE_TOKEN",
    "access_token": "YOUR_ACCESS_TOKEN"
  }'

# Connect a social media account
curl -X POST https://api.blog2social.com/rest/v1.0/network/add \
  -H "Content-Type: application/json" \
  -d '{
    "service_token": "YOUR_SERVICE_TOKEN",
    "access_token": "YOUR_ACCESS_TOKEN",
    "network_id": 1,
    "network_type_id": 0,
    "language": "en"
  }'

# Publish a post
curl -X POST https://api.blog2social.com/rest/v1.0/network/post/create \
  -H "Content-Type: application/json" \
  -d '{
    "service_token": "YOUR_SERVICE_TOKEN",
    "access_token": "YOUR_ACCESS_TOKEN",
    "client_user_network_id": 3241,
    "b2s_posts": [
      {
        "message": "Hello from cURL!",
        "postFormat": 0
      }
    ]
  }'

---

The official Blog2Social Node.js SDK provides a simple TypeScript-based interface for the Blog2Social API v1.0.

Use the SDK to authenticate users, connect social media accounts and publish content with just a few lines of JavaScript or TypeScript.

Installation

Install the SDK with npm:

npm install @adenion/blog2social-api-node-js-sdk

GitHub Repository

https://github.com/Adenion/blog2social-api-node-js-sdk

Requirements

• Node.js 18 or higher
• npm

Initialize the SDK

import { Blog2SocialClient } from '@adenion/blog2social-api-node-sdk';

const serviceToken = 'YOUR_SERVICE_TOKEN';

const client = new Blog2SocialClient({
    serviceToken
});

Authenticate a User

Before calling most API endpoints, a user must be authenticated.

const response = await client.authentication.authenticateUser();

const accessToken = response.access_token;

Store the returned access_token and refresh_token securely.

Initialize the client using both tokens:

const client = new Blog2SocialClient({
    serviceToken,
    accessToken
});

List Users

List all users associated with the current service.

const users = await client.user.listUsers();

console.log(users);

This endpoint only requires the serviceToken.

List Available Networks

const networks = await client.network.listNetwork();

console.log(networks);

List Network Properties

Retrieve network-specific publishing limits, media capabilities and video requirements.

const properties = await client.network.listProperties();

console.log(properties);

The returned properties can include:

• Supported image formats
• Supported video formats
• Character limits
• Title limits
• Video file-size limits
• Video length limits
• HTML support
• Emoji support
• Instant sharing support
• Video upload type

A video upload token is only generated when video_upload_type is 1.

Connect a Social Media Account

Example: Connect a Facebook Page.

const response = await client.connection.addNetwork(
    1,
    1,
    'en'
);

console.log(response.auth_link);

Redirect the user to the returned auth_link.

Network type values:

0 = Profile
1 = Page
2 = Group

List Connected Accounts

const connections = await client.user.listUserAuthentications();

console.log(connections);

The returned client_user_network_id is required when publishing posts.

Publish a Link Post

const clientUserNetworkId = YOUR_CLIENT_USER_NETWORK_ID;

const response = await client.share.createPost(
    clientUserNetworkId,
    [
        {
            client_user_network_id: clientUserNetworkId,
            title: 'My first API post',
            message: 'Hello from the Blog2Social Node.js SDK.',
            postFormat: 0,
            customUrl: 'https://example.com'
        }
    ]
);

console.log(response);

Post format values:

0 = Link
1 = Image
2 = Video

Publish an Image Post

const response = await client.share.createPost(
    clientUserNetworkId,
    [
        {
            client_user_network_id: clientUserNetworkId,
            title: 'Image Post',
            message: 'This is an image post.',
            postFormat: 1,
            mediaObjects: [
                {
                    type: 'IMAGE',
                    url: 'https://example.com/image.jpg'
                }
            ]
        }
    ]
);

console.log(response);

Publish a Video Post

Publish a video directly from a publicly accessible URL:

const response = await client.share.createPost(
    clientUserNetworkId,
    [
        {
            client_user_network_id: clientUserNetworkId,
            title: 'Video Post',
            message: 'This is a video post.',
            postFormat: 2,
            mediaObjects: [
                {
                    type: 'VIDEO',
                    url: 'https://example.com/video.mp4'
                }
            ]
        }
    ]
);

console.log(response);

Before choosing the video workflow, retrieve the network properties and check video_upload_type.

A video upload token is only generated when video_upload_type is 1.

Available Services

client.authentication;
client.network;
client.connection;
client.categories;
client.user;
client.share;
client.video;
client.videoUpload;
client.videoStatus;
client.app;
client.userApps;

---

The official Blog2Social PHP SDK provides a simple object-oriented interface for the Blog2Social API v1.0.

Use the SDK to authenticate users, connect social media accounts and publish content with just a few lines of PHP.

Installation

Install the SDK with Composer:

composer require adenion/blog2social-api-php-sdk

GitHub Repository

https://github.com/adenion/blog2social-api-php-sdk

Requirements

• PHP 8.1 or higher
• Composer
• PHP cURL extension
• PHP JSON extension

Initialize the SDK

<?php

declare(strict_types=1);

require __DIR__ . '/vendor/autoload.php';

use Adenion\Blog2Social\Sdk\Client\Blog2SocialClient;

$service_token = 'YOUR_SERVICE_TOKEN';

$client = new Blog2SocialClient(
    $service_token
);

Authenticate a User

Before calling most API endpoints, a user must be authenticated.

$response = $client
    ->authentication()
    ->authenticateUser();

$access_token = $response['access_token'];

Store the returned access_token and refresh_token securely.

Initialize the client using both tokens:

$client = new Blog2SocialClient(
    $service_token,
    $access_token
);

List Users

List all users associated with the current service.

$users = $client
    ->user()
    ->listUsers();

echo '<pre>';
print_r($users);
echo '</pre>';

This endpoint only requires the service_token.

List Available Networks

$networks = $client
    ->network()
    ->listNetwork();

echo '<pre>';
print_r($networks);
echo '</pre>';

List Network Properties

Retrieve network-specific publishing limits, media capabilities and video requirements.

$properties = $client
    ->network()
    ->listProperties();

echo '<pre>';
print_r($properties);
echo '</pre>';

The returned properties can include:

• Supported image formats
• Supported video formats
• Character limits
• Title limits
• Video file-size limits
• Video length limits
• HTML support
• Emoji support
• Instant sharing support
• Video upload type

A video upload token is only generated when video_upload_type is 1.

Connect a Social Media Account

Example: Connect a Facebook Page.

$response = $client
    ->connection()
    ->addNetwork(
        1,
        1,
        'en'
    );

header(
    'Location: ' . urldecode(
        $response['auth_link']
    )
);

exit;

Network type values:

0 = Profile
1 = Page
2 = Group

List Connected Accounts

$connections = $client
    ->user()
    ->listUserAuthentications();

echo '<pre>';
print_r($connections);
echo '</pre>';

The returned client_user_network_id is required when publishing posts.

Publish a Link Post

$client_user_network_id = YOUR_CLIENT_USER_NETWORK_ID;

$response = $client
    ->share()
    ->createPost(
        $client_user_network_id,
        [
            [
                'client_user_network_id' => $client_user_network_id,
                'title' => 'My first API post',
                'message' => 'Hello from the Blog2Social PHP SDK.',
                'postFormat' => 0,
                'customUrl' => 'https://example.com'
            ]
        ]
    );

echo '<pre>';
print_r($response);
echo '</pre>';

Post format values:

0 = Link
1 = Image
2 = Video

Publish an Image Post

$response = $client
    ->share()
    ->createPost(
        $client_user_network_id,
        [
            [
                'client_user_network_id' => $client_user_network_id,
                'title' => 'Image Post',
                'message' => 'This is an image post.',
                'postFormat' => 1,
                'mediaObjects' => [
                    [
                        'type' => 'IMAGE',
                        'url' => 'https://example.com/image.jpg'
                    ]
                ]
            ]
        ]
    );

Publish a Video Post

Publish a video directly from a publicly accessible URL:

$response = $client
    ->share()
    ->createPost(
        $client_user_network_id,
        [
            [
                'client_user_network_id' => $client_user_network_id,
                'title' => 'Video Post',
                'message' => 'This is a video post.',
                'postFormat' => 2,
                'mediaObjects' => [
                    [
                        'type' => 'VIDEO',
                        'url' => 'https://example.com/video.mp4'
                    ]
                ]
            ]
        ]
    );

Before choosing the video workflow, retrieve the network properties and check video_upload_type.

A video upload token is only generated when video_upload_type is 1.

Available Services

$client->authentication();
$client->network();
$client->connection();
$client->categories();
$client->user();
$client->share();
$client->video();
$client->videoUpload();
$client->videoStatus();
$client->app();
$client->userApps();

---

The Blog2Social API can be integrated directly into AI agents, AI assistants, coding assistants, automation platforms, and custom applications.

To simplify AI-powered integrations, Blog2Social provides two ways to connect AI applications with Blog2Social:

• MCP – Connect AI applications directly to Blog2Social using the Model Context Protocol.
• AI API Specification – Use the machine-readable API specification to build custom applications, integrations, SDKs, and AI-powered tools.

The Model Context Protocol (MCP) is an open standard that allows AI applications and agents to connect to external tools and services.

Blog2Social provides a hosted MCP server that allows compatible AI applications to interact directly with Blog2Social functionality.

The Blog2Social MCP endpoint is:

https://api.blog2social.com/mcp

The hosted MCP server requires no local installation.

Authentication is handled through OAuth, allowing users to securely connect their Blog2Social account to a supported AI application.

Generic MCP configuration

MCP clients use different configuration formats. Where a client accepts a remote MCP server URL, configure the Blog2Social server as follows:

{
  "name": "blog2social",
  "url": "https://api.blog2social.com/mcp"
}

Complete the Blog2Social OAuth flow when prompted. Do not add a Blog2Social password, service token, or access token to a client configuration file.

---