Blog2Social

Veröffentliche und automatisiere KI-generierte Inhalte über 25+ Social-Media- und Content-Plattformen mit Blog2Social. Verbinde Accounts, erstelle und veröffentliche Beiträge mit Text, Links, Bildern und Videos, verteile Inhalte über mehrere Netzwerke, plane Beiträge und rufe Veröffentlichungsergebnisse sowie verfügbare Insights ab. Ideal für KI-Agenten, Marketing-Automatisierung, Social-Media-Management und Multi-Channel-Content-Workflows.

View on blog2social.comTry this MCPSponsored

Hosted MCP Server

npx add-mcp 'https://api.blog2social.com/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

Blog2Social API (1.0.0)

Supported Platforms

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

Quick Start Guide

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

Authentication Model

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.

Prerequisites

A free Blog2Social API account to get started.

Step 1: Get Your API Key

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.

Step 2: Authenticate User

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.

Step 3: Get Available Networks

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.

Step 5: Retrieve Connected Accounts

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.

Step 6: Publish Your First Post

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.

Complete Workflow

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.

Publishing Result Format

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
}

Partial Success

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
}

Endpoints

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.

Testing and Sandbox

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

Open API Console

Authentication

Getting an Access Token

Get an access_token for a new user.

Note: Access tokens currently have a fixed validity period of 10 years. Automatic token refresh is planned for a future API release but is not available at this time.

Request Body schema: application/jsonrequired

service_token required	string The token for your service

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN" }

Response samples

200 Content type

application/json

{ - "access_token": "YOUR_ACCESS_TOKEN", - "refresh_token": "qwe111rtz222uio333", - "expired_in": "unix-timestamp" }

List OAuth user

List existing and active OAuth user

Request Body schema: application/jsonrequired

service_token required	string The token for your service

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN" }

Response samples

200 Content type

application/json

{ - "users": [ - { - "client_user_id": "1", - "access_token": "b2s_abcdef123546", - "refresh_token": "b2s_abcdef123546", - "access_date_time": "2001-01-01 01:01:01", - "refresh_date_time": "2001-01-01 01:01:01" } ] }

Delete OAuth user

Delete OAuth user from your service

Request Body schema: application/jsonrequired

service_token required	string The token for your service
users required	Array of integers List of OAuth user IDs to delete.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "users": [ - 123, - 456, - 789 ] }

Response samples

200 Content type

application/json

{ - "details": [ - { - "client_user_id": "1", - "deleted": "true | false", - "error": "empty | error_message" } ] }

Network

List Networks

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
format	string flag (default) - Denormalized flag structure (profile, page, group) \| type - Normalized type structure (network_type_id)

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN" }

Response samples

200 Content type

application/json

[ - { - "name": "X", - "url": "x.com", - "network_id": 2, - "profile": 1, - "page": 0, - "group": 0, - "network_type_id": 0 } ]

Add Connection

Get a link and session_token to redirect the user in order to authorize a network

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
network_id required	integer The ID of the social media network.
network_type_id required	integer The network type ID: 0 = Profile, 1 = Page, 2 = Group.
filter_level	string The filter applied to shown groups and pages by their access level. Currently available for VK (network 17) with the value "admin".
language	string The language used for the authorization flow or form.
service_conditions_id	integer The service conditions ID used when a custom application should be used instead of the default application.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "network_id": 1, - "network_type_id": 1, - "language": "en", - "service_conditions_id": 123 }

Response samples

200 Content type

application/json

{ - "auth_link": "https://api.blog2social.com/auth/v1/?b2s_session_token=abc123defg456hij789klm", - "session_token": "abc123defg456hij789klm", - "expired_in": "unix-timestamp" }

Update Connection

Get a link and session_token to redirect the user in order to re-authorize a network connection

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
client_user_network_id required	integer The ID of the user's connected social media account authorization.
network_id required	integer The ID of the social media network.
network_type_id required	integer The network type ID: 0 = Profile, 1 = Page, 2 = Group.
language	string The language used for the authorization flow or form.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "network_id": 1, - "network_type_id": 1, - "language": "en" }

Response samples

200 Content type

application/json

{ - "auth_link": "https://api.blog2social.com/auth/v1/?b2s_session_token=abc123defg456hij789klm", - "session_token": "abc123defg456hij789klm", - "expired_in": "unix-timestamp" }

List Categories

List categories/boards/subred/playlists a authorization can post to.
Only available for Pinterest, Reddit and YouTube.
Results are cached for 30 minutes.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
client_user_network_id required	integer The ID of the user's connected social media account authorization.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID" }

Response samples

200 Content type

application/json

[ - { - "id": "string", - "name": "string" } ]

List Network Properties

Returns network-specific publishing properties such as supported content types, limits, instant sharing support, media capabilities, video requirements and network-specific constraints.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN" }

Response samples

200 Content type

application/json

[ - { - "network_id": 1, - "network_type": 1, - "instant_sharing": 0, - "image_format": "png,jpg,gif,webp", - "reel_support": { - "reel_format": "mp4,mov", - "reel_max_length": 90, - "reel_min_length": 4, - "reel_min_framerate": 23, - "reel_aspect_ratio_x": 9, - "reel_aspect_ratio_y": 16, - "reel_min_resolution_x": 540, - "reel_min_resolution_y": 960 }, - "video_format": "mp4,mov", - "emoji_support": 1, - "html_support": null, - "video_support": 1, - "video_max_size": 256000, - "character_limit": 60000, - "video_max_length": 3600, - "video_upload_type": 0, - "character_limit_title": 0, - "video_max_size_original": 10485760 } ]

User

List User Connection

Get a list of all authorizations from a User
Results are cached for 30 minutes. (Cache will be cleared on any action to a authorization)

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN" }

Response samples

200 Content type

application/json

[ - { - "client_user_id": 1, - "client_user_network_id": 3241, - "network_id": 2, - "type": "profile", - "type_kind": 0, - "type_id": "3122312323378-8232312", - "display_name": "string", - "instant_sharing": 0, - "expired_date": "2022-07-03 14:00:00", - "last_user_update_date": "2021-07-03 14:00:00", - "name": "X" } ]

Delete User Connection

Delete a authorization from a User

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
client_user_network_id required	integer The ID of the user's connected social media account authorization.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID" }

Response samples

201 Content type

application/json

{ - "success": true }

Share to Network

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
client_user_network_id required	integer The ID of the user's connected social media account authorization.
b2s_posts required	Array of objects (PostObject)

Responses

Remove from Network

Remove content from a Network
A response of 200 OK only means, that we could request to the network without any error. Please check the response result for further information.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
client_user_network_id required	integer The id of the network authorization (required for single posts only / not for bulk)
b2s_posts required	Array of objects List of posts you want to remove

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "b2s_posts": [ - { - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "post_id": 1234, - "publish_link": "https://example.com/published-post" } ] }

Response samples

200 Content type

application/json

[ - { - "error": 0, - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "deleted_publish_link": "https://google.com/YOUR_CLIENT_USER_NETWORK_ID", - "extra": [ ] } ]

Insights

Get Total Insights

Get useful information on a post's performance such as likes, comments, reshares, impressions, mentions, profile views and/or video views
Results are cached for 20 hours.

Request Body schema: application/jsonrequired

Information needed to request insights from a network

Array

network_id	integer ID of the network
network_type	integer Enum: 0 1 2 type ID of the network (Profile: 0, Page: 1, Group: 2)
client_user_network_id	integer ID of the network authrization
extern_post_id	integer ID of the post given by the network

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "network_post_data": [ - { - "network_id": 2, - "network_type": 0, - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "extern_post_id": "YOUR_CLIENT_USER_NETWORK_ID0" } ] }

Response samples

200 Content type

application/json

[ - { - "intern_post_id": 2, - "extern_post_id": 13083961648621, - "network_id": 1, - "error": 0, } ]

Get Insights by time

Get Insights information at different timesteps. This makes it easy to plot diagrams from your insights data.
Results are cached for 1 hour.

Request Body schema: application/jsonrequired

specific request data

network_post_data	Array of objects
range	object Timeframe to fetch data from. It defaults to the last 3 days

Responses

Response samples

200 Content type

application/json

[ - { - "intern_post_id": 2, - "extern_post_id": 13083961648621, - "network_id": 1, - "error": 0, - "insights": { - "likes": { - "date": "2020-09-23 13:32:20", - "value": 1 }, - "reshares": { - "date": "2020-09-23 13:32:20", - "value": 1 }, - "impressions": { - "date": "2020-09-23 13:32:20", - "value": 1 }, - "mentions": { - "date": "2020-09-23 13:32:20", - "value": 1 }, - "profile_views": { - "date": "2020-09-23 13:32:20", - "value": 1 }, - "video_views": { - "date": "2020-09-23 13:32:20", - "value": 1 } } } ]

Enable Insights Entry

Enable an existing Insights Entry

Request Body schema: application/jsonrequired

Information needed to request insights from a network

Array

network_id	integer ID of the network
network_type	integer Enum: 0 1 2 type ID of the network (Profile: 0, Page: 1, Group: 2)
client_user_network_id	integer ID of the network authrization
extern_post_id	integer ID of the post given by the network

Responses

Request samples

Payload
cURL
PHP Content type

application/json

Response samples

Content type

application/json

{ - "error_code": 1002, - "error_message": "required parameter missing {PARAMETER}" }

Disable Insights Entry

Disable an existing Insights Entry

Request Body schema: application/jsonrequired

Information needed to request insights from a network

Array

network_id	integer ID of the network
network_type	integer Enum: 0 1 2 type ID of the network (Profile: 0, Page: 1, Group: 2)
client_user_network_id	integer ID of the network authrization
extern_post_id	integer ID of the post given by the network

Responses

Request samples

Payload
cURL
PHP Content type

application/json

Response samples

Content type

application/json

{ - "error_code": 1002, - "error_message": "required parameter missing {PARAMETER}" }

Video

Get a Video Token

Receive a video token for a video post. This is a separate video-token initialization workflow and intentionally uses the trailing-slash path and the items property. It must not be merged with the standard /network/post/create publisher.
A response of 200 OK only means the progress of sending the post was successfully handled by our API. Please check the result of the post on the network.

Request Body schema: application/jsonrequired

List of posts you want to create

Array

client_user_network_id	integer User network auth id to wich the post should go
title	string Set post title
message	string Set post message
postFormat	integer Value: 2 Set post format (Video: 2)
customUrl	string Set post url content
noCache	integer Enum: 0 1 If the link shoud get a no_cache parameter
tags	Array of strings Tags to post
board	string Pinterest board to post to
mediaObjects	Array of objects List of Media Objects to add to the post (For Facebook and X you can add up to 4 images, for Instagram up to 10 and for LinkedIn up to 9. Every other Network will only post the first image in the list)
is_retweet	integer Enum: 0 1 Indicator, if the post should be a retweet
network_post_id	string The id of the post you want to retweet
post_id	integer Identifier that will be returned with the Post Result Object, so you can pair it up with your request.
make_threads	integer Default: 0 Enum: 0 1 The post message gets cut and added as comments to the post if a message exceeds the character limit (X only)
ignore_link	integer Default: 0 Enum: 0 1 If enabled, the link URL won't be added to the end of the post message

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "items": [ - { - "client_user_network_id": 123, - "title": "Post title", - "message": "Hello from Blog2Social API!", - "postFormat": 2, - "customUrl": "https://example.com/post", - "noCache": 0, - "tags": [ - "string" ], - "board": "string", - "mediaObjects": [ - { - "type": { }, - "url": { } } ], - "is_retweet": 0, - "network_post_id": "string", - "post_id": 123, - "make_threads": 0, - "ignore_link": 0 } ] }

Response samples

200 Content type

application/json

[ - { - "error": 0, - "network_id": 32, - "type": 0, - "client_user_network_id": 1234567, - "extra": [ ], - "video_token": "abcedfghYOUR_CLIENT_USER_NETWORK_IDijklmnopq789012", - "video_upload_type": 0 } ]

Upload a Video

Upload the video file to our Video Server
After recieving a video_token, you will be able to upload your video in chunks to our video server. Make sure that the bytesize of the single chunks can be divided by 8 and that all chunks must have the same size (Except for the last chunk).

Request Body schema: multipart/form-dataoptional

video_token	string The token you recieved for a video upload
max_count_chunks	integer The count of chunks you split your video in
current_chunk	integer The current chunk you want to upload
chunk	string <binary> The binary video chunk file.

Responses

Request samples

Payload
cURL
PHP

{
  "video_token": "YOUR_VIDEO_TOKEN",
  "max_count_chunks": 1,
  "current_chunk": 1,
  "chunk": "@/path/to/file"
}

Response samples

200 Content type

application/json

{ - "error": 0, - "networks": [ - { - "error": 1, - "b2s_error_code": "VIDEO_NETWORK_LENGTH | VIDEO_NETWORK_SIZE | VIDEO_NETWORK_FORMAT", - "network_id": 36, - "client_user_network_id": "YOUR_CLIENT_USER_NETWORK_ID", - "instant_sharing": 0, - "post_id": 11 } ] }

Get Video Post Results

Request Body schema: application/jsonrequired

video_token required	string The video token received before uploading video chunks.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "video_token": "YOUR_VIDEO_TOKEN" }

Response samples

200 Content type

application/json

[ - { - "network_id": 12, - "network_type": 1, - "state": 0, - "client_user_network_id": 3241, - "publish_url": "https:\\/\\/www.instagram.com\\/p\\/Cjr5AnINUD5\\/", - "post_id": 5 }, - { - "network_id": 32, - "network_type": 0, - "state": 1, - "client_user_network_id": 3241, - "b2s_error_code": "VIDEO_NETWORK_FORMAT", - "post_id": 6 } ]

User Apps

Add a User App

Add a User App for a specific network. That User App can be used for authorizations whithin these Networks.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
network_id required	integer The ID of the social media network.
app_key required	string
app_secret required	string The application secret.
app_name required	string

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "network_id": 1, - "app_key": "YOUR_APP_KEY", - "app_secret": "YOUR_APP_SECRET", - "app_name": "Example App" }

Response samples

200 Content type

application/json

{ - "error": false, - "user_app_id": "YOUR_CLIENT_USER_NETWORK_ID", - "service_conditions_id": 456789 }

List all User Apps

List all User Apps for a given access_token.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN" }

Response samples

200 Content type

application/json

{ - "error": false, - "user_apps": [ - { - "name": "Example App", - "network_details_id": "YOUR_CLIENT_USER_NETWORK_ID", - "network_id": 32, - "app_key": "****abcd", - "app_secret": "****abcd" } ] }

Modify a User Apps

Modify the details of a User Apps.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
user_app_id required	integer
app_name required	string
app_key required	string
app_secret required	string The application secret.

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "user_app_id": 1, - "app_name": "Example App", - "app_key": "YOUR_APP_KEY", - "app_secret": "YOUR_APP_SECRET" }

Response samples

200 Content type

application/json

{ - "error": false }

Delete a User Apps

Permamently delete a User Apps.

Request Body schema: application/jsonrequired

service_token required	string The token for your service
access_token required	string The access token for the authenticated user.
user_app_id required	integer

Responses

Request samples

Payload
cURL
PHP Content type

application/json

{ - "service_token": "YOUR_SERVICE_TOKEN", - "access_token": "YOUR_ACCESS_TOKEN", - "user_app_id": 1 }

Response samples

200 Content type

application/json

{ - "error": false, - "inactive_auth_ids": [ - 123, - 456, - 789 ] }

Integrations

SDKs & CLI

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.

cURL

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
      }
    ]
  }'

Node.js

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;

PHP

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
    ->()
    ->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
    ->()
    ->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
    ->()
    ->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();

AI Agents

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.

MCP

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 or access token to a client configuration file.

Endpoint

Use the following endpoint when connecting an MCP-compatible application:

https://api.blog2social.com/mcp

MCP Distribution

Blog2Social MCP is available through MCP directories and distribution platforms, making it easier to discover and connect the hosted Blog2Social MCP server from compatible AI applications and MCP clients.

Available MCP Directories

Smithery — Discover and connect to the Blog2Social MCP server through the Smithery MCP directory.
Glama — Discover and connect to the Blog2Social MCP server through the Glama MCP directory.

Authentication is handled through the Blog2Social OAuth flow. Users do not need to provide their Blog2Social password or manually configure an access token.

Authentication

Blog2Social MCP uses OAuth authentication.

The general authentication flow is:

AI Application
       ↓
Blog2Social MCP
       ↓
Blog2Social OAuth
       ↓
Login & Authorization
       ↓
MCP Connection
       ↓
Blog2Social MCP Tools

You do not need to provide your Blog2Social password directly to the AI application.

Error Handling

Blog2Social MCP uses HTTP status codes and JSON-RPC 2.0 error codes to report errors. The HTTP status describes the request outcome, while the JSON-RPC code identifies the protocol or application error.

HTTP and JSON-RPC errors

HTTP status	MCP code	Error
`405`	`-32601`	Method not allowed - HTTP method is not supported
`415`	`-32600`	Invalid request - Content-Type must be `application/json`
`406`	`-32600`	Invalid request - Accept must include `application/json` and `text/event-stream`
`400`	`-32600`	Invalid request - Request body is required
`400`	`-32700`	Parse error - Invalid JSON
`400`	`-32600`	Invalid request - Invalid JSON-RPC request
`200`	`-32601`	Method not found - Unknown JSON-RPC method

Session and initialization errors

HTTP status	MCP code	Error
`400`	`-32602`	MCP session ID required
`400`	`-32602`	MCP session not found or expired
`400`	`-32602`	MCP-Protocol-Version header required
`400`	`-32602`	MCP protocol version does not match the session
`400`	`-32602`	MCP session is not initialized
`400`	`-32602`	MCP session is already initialized
`400`	`-32602`	Invalid initialize params - Expected an object
`400`	`-32602`	Protocol version required
`400`	`-32602`	`clientInfo` is required
`400`	`-32602`	`clientInfo.name` is required
`400`	`-32602`	`clientInfo.version` is required
`400`	`-32602`	`capabilities` is required

tools/list and tools/call errors

HTTP status	MCP code	Error
`400`	`-32602`	Invalid `tools/list` parameters
`400`	`-32602`	`tools/list` cursor must be a string
`400`	`-32602`	Invalid `tools/list` cursor
`400`	`-32602`	`tools/call` params must be an object
`400`	`-32602`	Tool name required
`400`	`-32602`	`tools/call` arguments must be an object
`200`	`-32602`	Unknown tool: `{tool_name}`

Authentication and authorization errors

HTTP status	MCP code	Error
`401`	`-32001`	Access token required
`403`	`-32001`	Access token invalid
`403`	`-32001`	Access token expired
`403`	`-32001`	App state invalid
`403`	`-32001`	App is not active
`403`	`-32001`	App is suspended
`403`	`-32001`	Service ID invalid
`403`	`-32001`	No user service found
`403`	`-32001`	No client user auth data found
`403`	`-32001`	Invalid client user
`403`	`-32001`	No client user access token found
`403`	`-32001`	Client user access token is inactive
`403`	`-32001`	Client user access token expired
`401`	`-32001`	Service token required
`403`	`-32001`	Service token invalid
`401`	`-32001`	Service authentication required
`401`	`-32001`	Access token invalid
`401`	`-32001`	Access token expired
`403`	`-32001`	Access token does not belong to this service

Internal MCP session errors

HTTP status	MCP code	Error
`500`	`-32603`	Unable to create MCP session
`500`	`-32603`	MCP session state is incomplete
`500`	`-32603`	Unable to persist MCP session
`500`	`-32603`	Unable to load MCP session
`500`	`-32603`	Unable to terminate MCP session

JSON-RPC error response

MCP errors use the JSON-RPC 2.0 error response format:

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "MCP session ID required"
  }
}

The code identifies the JSON-RPC or MCP error, while message provides a human-readable description of the problem.

Supported AI Applications

Blog2Social MCP is compatible with the following AI applications, coding assistants, development environments, and automation platforms:

Application	MCP support
ChatGPT	Depends on MCP/connector availability
Claude	Depends on MCP/connector availability
Claude Desktop	Depends on MCP configuration and OAuth
Cline	Depends on MCP configuration and OAuth
GitHub Copilot	Depends on MCP configuration and OAuth
Cursor	Depends on MCP configuration and OAuth
MCPJam	MCP client; verify OAuth support
Mistral	Depends on MCP/connector availability
n8n	Depends on MCP configuration and OAuth
Notion	Depends on MCP configuration and OAuth
Slackbot	Depends on MCP configuration and OAuth
VS Code	Depends on MCP configuration and OAuth

Support depends on the respective application's MCP and OAuth capabilities.

Connect from Claude

Blog2Social MCP can be connected to Claude using the hosted MCP server.

Connect from the Claude.ai website

Open Claude.
Open Settings or Connectors.
Select Add custom connector.
Enter the Blog2Social MCP endpoint:

https://api.blog2social.com/mcp

Add the connector.
Follow the Blog2Social OAuth authentication flow.
Log in to your Blog2Social account.
Authorize the connection.

After successful authorization, Blog2Social is available as an MCP connector in Claude.

You can then use natural-language instructions to interact with the available Blog2Social functionality.

Note: The exact location and naming of connector settings may vary depending on the current Claude interface and account type.

Connect from Claude Desktop

Claude Desktop supports MCP integrations.

Add the Blog2Social MCP server using the following endpoint:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth authentication process when prompted.

After authorization, Claude Desktop can access the Blog2Social MCP tools available to your account.

Connect from ChatGPT

ChatGPT can connect to MCP servers through its supported connector or app integration capabilities.

Use the Blog2Social MCP endpoint:

https://api.blog2social.com/mcp

Follow the authentication flow provided by ChatGPT.

When redirected to Blog2Social, log in to your Blog2Social account and authorize the connection.

After authorization, ChatGPT can use the Blog2Social MCP tools available through the connection.

Note: The exact location and naming of MCP or connector settings may change as ChatGPT updates its MCP and app integration capabilities.

Connect from Cursor

Cursor supports MCP servers and can connect to the Blog2Social hosted MCP server.

Add the Blog2Social MCP server to your Cursor MCP configuration.

Use:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth authentication flow when prompted.

After successful authentication, Blog2Social MCP tools are available to supported Cursor workflows.

Connect from Cline

Cline supports MCP integrations.

Add the Blog2Social MCP server using:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth authorization process.

After authentication, Cline can discover and use the Blog2Social MCP tools available through the connection.

Connect from GitHub Copilot

GitHub Copilot environments that support MCP can connect to Blog2Social through the hosted MCP server.

Use:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth authentication flow when requested.

After authorization, Copilot can use the Blog2Social MCP tools supported by the connection.

Connect from Mistral

Mistral environments that support MCP can connect to Blog2Social using the hosted MCP endpoint:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth login and authorize the connection.

After authorization, Blog2Social MCP functionality can be used by supported Mistral workflows.

Connect from n8n

n8n can use MCP-compatible connections to integrate Blog2Social into automated workflows.

Use the Blog2Social MCP endpoint:

https://api.blog2social.com/mcp

Authenticate using the Blog2Social OAuth flow.

This allows Blog2Social functionality to be combined with AI-powered automation workflows.

For example:

Trigger
   ↓
AI / Content Generation
   ↓
Blog2Social MCP
   ↓
Create Content
   ↓
Publish or hand off

Blog2Social MCP can therefore be used as part of larger automated workflows without implementing the Blog2Social API directly in every workflow.

Connect from Notion

Notion environments that support MCP can connect to Blog2Social through the hosted MCP endpoint:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth authorization flow when requested.

After authorization, Blog2Social MCP functionality can be used within supported Notion MCP and AI workflows.

Connect from Slackbot

Slackbot environments that support MCP can connect to Blog2Social using:

https://api.blog2social.com/mcp

Authenticate with your Blog2Social account through OAuth and authorize the connection.

After successful authentication, supported Slackbot workflows can interact with Blog2Social through MCP.

Connect from VS Code

VS Code environments that support MCP can connect to Blog2Social through the hosted MCP endpoint:

https://api.blog2social.com/mcp

Add the endpoint to your MCP configuration and complete the Blog2Social OAuth authorization flow.

After authorization, Blog2Social MCP tools can be used from supported AI coding and agent workflows inside VS Code.

Connect from MCPJam

MCPJam can be used to inspect and work with MCP servers.

Use the Blog2Social MCP endpoint:

https://api.blog2social.com/mcp

Complete the Blog2Social OAuth authentication flow and authorize access to your Blog2Social account.

Once authenticated, MCPJam can interact with the available Blog2Social MCP tools.

MCP and Blog2Social

MCP provides a standardized interface between AI applications and Blog2Social.

The general architecture looks like this:

AI Assistant
      |
      | MCP
      v
Blog2Social MCP Server
      |
      | Blog2Social API
      v
Blog2Social
      |
      +-- Social Networks
      +-- Connected Accounts
      +-- Posts
      +-- Publishing

This allows AI applications to work with Blog2Social without requiring a separate custom integration for every AI platform.

OAuth Authentication

Blog2Social MCP uses OAuth for authentication and authorization.

The authentication process allows users to connect their Blog2Social account without providing their Blog2Social password directly to the AI application.

The general process is:

1. Connect AI application
          ↓
2. Enter Blog2Social MCP endpoint
          ↓
3. Start OAuth authentication
          ↓
4. Log in to Blog2Social
          ↓
5. Authorize the application
          ↓
6. Return to the AI application
          ↓
7. Blog2Social MCP connection is active

OAuth provides the authorization layer between the AI application and the Blog2Social account.

Always review the authorization request before approving a connection.

MCP vs. Blog2Social API

Blog2Social provides different integration options depending on your use case.

Integration	Use case
MCP	AI assistants, AI agents, natural-language workflows
REST API	Custom applications and backend integrations
AI API Specification	AI-assisted API development and code generation
Automation platforms	Automated workflows and integrations

MCP is particularly useful when an AI assistant or AI agent needs to interact with Blog2Social through standardized tools.

The REST API remains available for applications that require direct programmatic access to Blog2Social.

MCP Prompts and Examples

After connecting Blog2Social MCP, you can interact with Blog2Social using natural-language instructions.

Create a social media post

Create a social media post announcing our new blog article.

Request a scheduled publishing action

Publish this Facebook post tomorrow at 8:00 AM.

The instruction can be understood by an AI client as a requested publication time. The Blog2Social REST API specification currently documents publishing, but does not define a scheduling endpoint. The AI client or connected MCP tools must therefore provide the scheduling capability; otherwise the client should explain that it can prepare or publish the post, but cannot schedule it.

Create platform-specific content

Create versions of this announcement for LinkedIn, Facebook and X.

Publish content

Publish this announcement to my connected social media accounts.

Create a campaign

Create a social media campaign for our new blog article.

Prepare posts for the relevant social networks with the requested
publication times over the next week.

Generate content from an article

Turn this article into social media posts for LinkedIn,
Facebook and Instagram and prepare them for later publishing.

Prepare content for review

Create three social media posts about our new product.

Do not publish anything yet.
I want to review the posts first.

The exact actions available depend on the Blog2Social MCP tools and the permissions granted to the connected account.

Human-in-the-Loop Workflows

MCP can also be used for workflows where AI prepares content while the user remains in control of the final publishing action.

For example:

AI generates content
        ↓
Blog2Social MCP
        ↓
Create / Prepare Content
        ↓
Human Review
        ↓
Request publication or publish

A typical workflow could be:

Create three social media posts about our new product.
Do not publish anything yet.

After reviewing the generated content:

The second post looks good.
Publish it to LinkedIn tomorrow at 9 AM.

This allows AI to assist with content creation and workflow automation while keeping the final publishing decision with the user.

Security and Authorization

Blog2Social MCP uses OAuth for account authorization.

Your Blog2Social password is not provided to the AI model as part of an MCP request.

Authentication is handled through the Blog2Social OAuth flow.

As with any third-party integration, only authorize MCP clients and applications that you trust.

Always review the authorization request before granting access.

AI API Specification

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

To simplify AI-powered integrations, Blog2Social provides a machine-readable OpenAPI specification optimized for automated code generation and API understanding.

Use the following AI-optimized API specification to generate applications, SDKs, integrations, or custom tools with your preferred AI assistant.

https://docs.blog2social.com/api/ai-specification.json

The document contains the complete Blog2Social API description, including endpoints, request and response schemas, authentication, examples, and data models.

It is optimized for AI coding assistants such as ChatGPT, Claude, Gemini, Cursor, GitHub Copilot, and similar developer tools, enabling them to understand the API and generate integrations more effectively.

The AI API specification is continuously updated alongside the Blog2Social API and should be used as the primary source for AI-assisted development.

The AI API Specification helps developers and AI coding assistants understand the Blog2Social REST API and generate custom integrations.

AI Coding Assistant
      ↓
AI API Specification
      ↓
Custom Application
      ↓
Blog2Social API

You can use both approaches depending on your requirements.

Platform Guides

Learn how to connect, manage and publish content on supported platforms using the Blog2Social API.

Each guide provides platform-specific information, supported content types, media requirements, publishing examples, best practices and API workflows.

The guides help you understand platform-specific capabilities, optimize content publishing and build efficient social media automation workflows.

Topics covered in each guide:

Account connection and authorization
Supported content and media types
Publishing workflows
Platform-specific requirements
Best practices and recommendations
Analytics and insights
Example API requests and responses
Common use cases

Use these guides to get the most out of each platform while working with a unified API experience.

Band

Publish content to Band through the Blog2Social API.

Band is a community platform designed for groups, teams and organizations. Use the Blog2Social API to connect Band accounts, publish posts and automate group communication workflows.

Supported Content Types

Posts

Supported Media

Images

Connect a Band Account

Retrieve available networks using /network/list
Select the Band network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Band Post

Use postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Band Post",
  "message": "Hello Band",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Band Use Cases

Group Communication
Team Updates
Community Management
Event Announcements
Organization News

Best Practices

Keep messages clear and informative.
Use images to increase engagement.
Share updates relevant to your group.
Store the client_user_network_id for future publishing.
Publish consistently to keep members informed.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Blogger

Publish content to Blogger through the Blog2Social API.

Blogger is a blogging platform for publishing articles, updates and long-form content. Use the Blog2Social API to connect Blogger accounts, publish articles and automate blog content distribution.

Supported Content Types

Articles

Supported Media

Images

Connect a Blogger Account

Retrieve available networks using /network/list
Select the Blogger network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Blogger Article

Use postFormat = 1 when publishing article content with images.

Example:

{
  "client_user_network_id": 3241,
  "title": "Blogger Article",
  "message": "This is the article content for Blogger.",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Blogger Use Cases

Blog Publishing
Content Marketing
Article Distribution
Brand Publishing
Automated Blog Workflows

Best Practices

Use clear titles and structured content.
Add relevant images where useful.
Keep article content informative and readable.
Store the client_user_network_id for future publishing.
Reuse successful content across publishing workflows.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Bloglovin

Publish content to Bloglovin through the Blog2Social API.

Bloglovin is a platform for discovering, following and sharing blog content. Use the Blog2Social API to connect Bloglovin accounts, publish blog posts and automate blog content distribution.

Supported Content Types

Blog Posts

Supported Media

Images

Connect a Bloglovin Account

Retrieve available networks using /network/list
Select the Bloglovin network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Bloglovin Post

Use postFormat = 1 when publishing blog content with images.

Example:

{
  "client_user_network_id": 3241,
  "title": "Bloglovin Post",
  "message": "New blog content is available.",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Bloglovin Use Cases

Blog Content Distribution
Content Discovery
Audience Growth
Brand Publishing
Automated Blog Promotion

Best Practices

Use clear titles and descriptions.
Add relevant images where useful.
Keep content aligned with your blog audience.
Store the client_user_network_id for future publishing.
Reuse successful blog content across publishing workflows.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Bluesky

Publish content to Bluesky through the Blog2Social API.

Bluesky is a decentralized social media platform for public conversations, communities and real-time updates. Use the Blog2Social API to connect Bluesky accounts, publish posts and automate social media distribution.

Supported Content Types

Posts

Supported Media

Links
Images

Connect a Bluesky Account

Retrieve available networks using /network/list
Select the Bluesky network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Bluesky Post

Use postFormat = 0 for link posts or postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Bluesky Post",
  "message": "Hello Bluesky",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Common Bluesky Use Cases

Social Publishing
Community Updates
Brand Communication
Content Distribution
Audience Engagement

Best Practices

Keep posts concise and relevant.
Use images to increase engagement.
Include links when driving traffic.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

DEV.to

Publish content to DEV.to through the Blog2Social API.

DEV.to is a publishing platform for developers, technical writers and software communities. Use the Blog2Social API to connect DEV.to accounts, publish articles and distribute technical content automatically.

Supported Content Types

Articles

Supported Media

Images
Videos

Connect a DEV.to Account

Retrieve available networks using /network/list
Select the DEV.to network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a DEV.to Article

Use postFormat = 1 for image articles or postFormat = 2 when video media is included.

Example:

{
  "client_user_network_id": 3241,
  "title": "DEV.to Article",
  "message": "This is the article content for DEV.to.",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common DEV.to Use Cases

Technical Content Publishing
Developer Relations
Product Updates
Engineering Blogs
Community Building

Best Practices

Use clear technical titles.
Structure content for readability.
Add relevant images or media when useful.
Store the client_user_network_id for future publishing.
Share valuable and practical content for developer audiences.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Diigo

Publish content to Diigo through the Blog2Social API.

Diigo is a bookmarking and research platform for saving, organizing and sharing useful links. Use the Blog2Social API to connect Diigo accounts, publish bookmarks and automate link distribution workflows.

Supported Content Types

Bookmarks

Supported Media

Links

Connect a Diigo Account

Retrieve available networks using /network/list
Select the Diigo network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Diigo Bookmark

Use postFormat = 0 and provide a URL via customUrl.

Example:

{
  "client_user_network_id": 3241,
  "title": "Diigo Bookmark",
  "message": "Useful resource",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Common Diigo Use Cases

Bookmark Publishing
Link Distribution
Research Collection
Content Curation
Knowledge Sharing

Best Practices

Use clear and descriptive titles.
Add meaningful context in the message.
Ensure the URL is publicly accessible.
Store the client_user_network_id for future publishing.
Keep shared links relevant and useful.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Discord

Publish content to Discord through the Blog2Social API.

Discord is a community platform for servers, channels and direct audience communication. Use the Blog2Social API to connect Discord accounts, publish messages and automate community updates.

Supported Content Types

Messages

Supported Media

Images
Videos

Connect a Discord Account

Retrieve available networks using /network/list
Select the Discord network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Discord Message

Use postFormat = 1 for image messages or postFormat = 2 for video messages.

Example:

{
  "client_user_network_id": 3241,
  "title": "Discord Message",
  "message": "Hello Discord",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Discord Use Cases

Community Updates
Server Announcements
Content Distribution
Product Updates
Audience Communication

Best Practices

Keep messages clear and relevant.
Use images or videos for important updates.
Publish content to the right connected account.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Facebook

Publish content to Facebook through the Blog2Social API.

Facebook remains one of the world's largest social media platforms for businesses, creators and communities. Use the Blog2Social API to connect Facebook profiles, pages and groups, publish content automatically and streamline social media workflows.

Supported Content Types

Posts
Reels

Supported Media

Links
Images
Videos

Connect a Facebook Account

Retrieve available networks using /network/list
Select the Facebook network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Facebook Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Facebook Post",
  "message": "Hello Facebook",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Retrieve Post Insights

Use the Insights endpoints to retrieve engagement and performance metrics for published Facebook content.

Available endpoints:

/network/post/insights/total
/network/post/insights/graph

Common Facebook Use Cases

Business Page Publishing
Community Management
Marketing Automation
Content Distribution
Agency Dashboards

Best Practices

Use engaging images and videos.
Keep posts concise and relevant.
Store the client_user_network_id for future publishing.
Track performance using Insights.
Automate recurring publishing workflows.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create
/network/post/insights/total
/network/post/insights/graph

Flickr

Publish content to Flickr through the Blog2Social API.

Flickr is a media-focused platform for sharing photography, visual content and creative portfolios. Use the Blog2Social API to connect Flickr accounts, publish media posts and automate visual content distribution.

Supported Content Types

Media Posts

Supported Media

Images
Videos

Connect a Flickr Account

Retrieve available networks using /network/list
Select the Flickr network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Flickr Media Post

Use postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Flickr Media Post",
  "message": "Hello Flickr",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Flickr Use Cases

Photography Publishing
Visual Portfolio Distribution
Creative Media Sharing
Brand Image Publishing
Content Archiving

Best Practices

Use high-quality images and videos.
Add clear titles and descriptions.
Keep media URLs publicly accessible.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Google Business Profile

Publish content to Google Business Profile through the Blog2Social API.

Google Business Profile helps businesses publish updates, offers and announcements directly to their business presence on Google. Use the Blog2Social API to connect Google Business Profile accounts, publish business posts and automate local marketing workflows.

Supported Content Types

Business Posts

Supported Media

Images

Connect a Google Business Profile

Retrieve available networks using /network/list
Select the Google Business Profile network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Business Post

Use postFormat = 1 for image posts

Example:

{
  "client_user_network_id": 3241,
  "title": "Business Update",
  "message": "New update from our business",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Google Business Profile Use Cases

Local Business Updates
Offers and Promotions
Event Announcements
Local SEO Support
Brand Visibility

Best Practices

Use clear and helpful business updates.
Add relevant images.
Keep messages accurate and locally relevant.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create
/network/post/remove

HumHub

Publish content to HumHub through the Blog2Social API.

HumHub is a social networking and collaboration platform for organizations, communities and teams. Use the Blog2Social API to connect HumHub accounts, publish posts and automate internal or community communication.

Supported Content Types

Posts

Supported Media

Images

Connect a HumHub Account

Retrieve available networks using /network/list
Select the HumHub network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a HumHub Post

Use postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "HumHub Post",
  "message": "Hello HumHub",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common HumHub Use Cases

Team Communication
Community Updates
Internal Collaboration
Organization Announcements
Knowledge Sharing

Best Practices

Share clear and relevant updates.
Use images where appropriate.
Publish content that benefits your community.
Store the client_user_network_id for future publishing.
Monitor engagement and publishing results.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Instagram

Publish content to Instagram through the Blog2Social API.

Instagram is one of the world's leading social media platforms for visual content and audience engagement. Use the Blog2Social API to connect Instagram accounts, publish image and video content, and automate Instagram publishing workflows.

Supported Content Types

Image Posts
Video Posts

Supported Media

Single Images
Multiple Images (Carousel Posts)
Videos

Connect an Instagram Account

Retrieve available networks using /network/list
Select the Instagram network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish an Image Post

Use postFormat = 1 and provide one or more image URLs in mediaObjects.

Example:

{
  "client_user_network_id": 3241,
  "title": "Instagram Image Post",
  "message": "Hello Instagram",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Publish a Video Post

Use postFormat = 2 and provide a video URL.

Example:

{
  "client_user_network_id": 3241,
  "title": "Instagram Video Post",
  "message": "Hello Instagram",
  "postFormat": 2,
  "mediaObjects": [
    {
      "type": "VIDEO",
      "url": "https://example.com/video.mp4"
    }
  ]
}

Retrieve Post Insights

Use the Insights endpoints to retrieve engagement and performance metrics for published Instagram content.

Available endpoints:

/network/post/insights/total
/network/post/insights/graph

Common Instagram Use Cases

Social Media Management Platforms
Marketing Automation Tools
Content Scheduling Solutions
Agency Dashboards
Creator Management Platforms

Best Practices

Use high-quality images and videos.
Keep captions concise and engaging.
Validate media URLs before publishing.
Store the client_user_network_id for future publishing.
Monitor post performance using Insights.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create
/network/post/insights/total
/network/post/insights/graph

Instapaper

Publish content to Instapaper through the Blog2Social API.

Instapaper is a platform for saving, organizing and reading web content. Use the Blog2Social API to connect Instapaper accounts, publish saved content and automate link-based content workflows.

Supported Content Types

Saved Content

Supported Media

Links

Connect an Instapaper Account

Retrieve available networks using /network/list
Select the Instapaper network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish Saved Content

Use postFormat = 0 and provide a URL via customUrl.

Example:

{
  "client_user_network_id": 3241,
  "title": "Instapaper Content",
  "message": "Saved content for later reading",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Common Instapaper Use Cases

Saved Content Publishing
Reading List Automation
Link Collection
Content Curation
Research Workflows

Best Practices

Use clear and descriptive titles.
Provide useful context in the message.
Ensure the URL is publicly accessible.
Store the client_user_network_id for future publishing.
Keep saved content relevant and organized.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Publish content to LinkedIn through the Blog2Social API.

LinkedIn is the world's leading professional networking platform for businesses, brands and professionals. Use the Blog2Social API to connect LinkedIn accounts, publish content automatically and streamline professional content distribution.

Supported Content Types

Posts

Supported Media

Links
Images
Videos

Connect a LinkedIn Account

Retrieve available networks using /network/list
Select the LinkedIn network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "LinkedIn Post",
  "message": "Hello LinkedIn",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Retrieve Post Insights

Use the Insights endpoints to retrieve engagement and performance metrics for published content.

Available endpoints:

/network/post/insights/total
/network/post/insights/graph

Common LinkedIn Use Cases

Professional Content Distribution
Thought Leadership
Company Updates
Employer Branding
B2B Marketing

Best Practices

Share valuable and professional content.
Use images and videos to increase engagement.
Include relevant links and calls to action.
Store the client_user_network_id for future publishing.
Monitor performance using Insights.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create
/network/post/insights/total
/network/post/insights/graph

Mastodon

Publish content to Mastodon through the Blog2Social API.

Mastodon is a decentralized social media platform for public conversations, communities and topic-based communication. Use the Blog2Social API to connect Mastodon accounts, publish posts and automate content distribution.

Supported Content Types

Posts

Supported Media

Links
Images
Videos

Connect a Mastodon Account

Retrieve available networks using /network/list
Select the Mastodon network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Mastodon Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Mastodon Post",
  "message": "Hello Mastodon",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Common Mastodon Use Cases

Community Publishing
Decentralized Social Media
Topic-Based Communication
Content Distribution
Brand Updates

Best Practices

Keep posts relevant to your audience.
Use links, images or videos when appropriate.
Respect community norms and instance rules.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Medium

Publish content to Medium through the Blog2Social API.

Medium is a publishing platform for articles, stories and thought leadership content. Use the Blog2Social API to connect Medium accounts, publish articles and distribute long-form content automatically.

Supported Content Types

Articles

Supported Media

Images

Connect a Medium Account

Retrieve available networks using /network/list
Select the Medium network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Medium Article

Use postFormat = 1 with image content when media is included.

Example:

{
  "client_user_network_id": 3241,
  "title": "Medium Article",
  "message": "This is the article content for Medium.",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Medium Use Cases

Thought Leadership
Blog Distribution
Content Marketing
Brand Publishing
Long-Form Articles

Best Practices

Use clear titles and structured article content.
Add relevant images to improve readability.
Keep content valuable and informative.
Store the client_user_network_id for future publishing.
Reuse successful content across publishing workflows.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Publish content to Pinterest through the Blog2Social API.

Pinterest is a visual discovery platform for inspiration, products, ideas and long-term content visibility. Use the Blog2Social API to connect Pinterest accounts, publish pins and manage board-based publishing workflows.

Supported Content Types

Pins
Boards

Supported Media

Images
Videos

Connect a Pinterest Account

Retrieve available networks using /network/list
Select the Pinterest network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Retrieve Boards

Use /network/categories to retrieve available Pinterest boards for a connected account.

Publish a Pin

Use postFormat = 1 for image pins or postFormat = 2 for video pins.

Example:

{
  "client_user_network_id": 3241,
  "title": "Pinterest Pin",
  "message": "Discover more on our website",
  "postFormat": 1,
  "customUrl": "https://example.com",
  "board": "BOARD_ID",
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Pinterest Use Cases

Product Promotion
Visual Content Distribution
Blog Traffic Generation
E-Commerce Marketing
Evergreen Content Promotion

Best Practices

Use high-quality vertical images.
Add clear titles and descriptions.
Include a relevant destination URL.
Publish to the correct board.
Store the client_user_network_id for future publishing.

Related Endpoints

/network/list
/network/add
/network/categories
/user/auth/list
/network/post/create

Ravelry

Publish content to Ravelry through the Blog2Social API.

Ravelry is a community platform for fiber artists, designers and craft-related content. Use the Blog2Social API to connect Ravelry accounts, publish posts and automate content distribution.

Supported Content Types

Posts

Supported Media

Images

Connect a Ravelry Account

Retrieve available networks using /network/list
Select the Ravelry network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Ravelry Post

Use postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Ravelry Post",
  "message": "Hello Ravelry",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Ravelry Use Cases

Community Publishing
Craft Content Distribution
Pattern Promotion
Creator Updates
Niche Audience Engagement

Best Practices

Use clear and relevant images.
Keep messages useful for the community.
Publish content that fits the audience.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Publish content to Reddit through the Blog2Social API.

Reddit is a community-driven platform for discussions, niche communities and topic-based content distribution. Use the Blog2Social API to connect Reddit accounts, publish posts and manage subreddit-based publishing workflows.

Supported Content Types

Posts
Subreddits

Supported Media

Links
Images

Connect a Reddit Account

Retrieve available networks using /network/list
Select the Reddit network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Retrieve Subreddits

Use /network/categories to retrieve available subreddits for a connected account.

Publish a Reddit Post

Use postFormat = 0 for link posts or postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Reddit Post",
  "message": "Hello Reddit",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Common Reddit Use Cases

Community Engagement
Topic-Based Content Distribution
Product Feedback
Content Promotion
Niche Marketing

Best Practices

Publish relevant content for each subreddit.
Follow subreddit rules and guidelines.
Use clear titles and helpful descriptions.
Avoid overly promotional content.
Store the client_user_network_id for future publishing.

Related Endpoints

/network/list
/network/add
/network/categories
/user/auth/list
/network/post/create

Publish content to Telegram through the Blog2Social API.

Telegram is a messaging and channel platform for fast content distribution, community updates and direct audience communication. Use the Blog2Social API to connect Telegram channels and publish messages automatically.

Supported Content Types

Messages

Supported Media

Links
Images

Connect a Telegram Account

Retrieve available networks using /network/list
Select the Telegram network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Telegram Message

Use postFormat = 0 for link posts, postFormat = 1 for image posts

Example:

{
  "client_user_network_id": 3241,
  "title": "Telegram Message",
  "message": "Hello Telegram",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Telegram Use Cases

Channel Updates
Community Communication
News Distribution
Marketing Automation
Content Broadcasting

Best Practices

Keep messages clear and direct.
Use images for important announcements.
Publish relevant updates to the right channel.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Threads

Publish content to Threads through the Blog2Social API.

Threads is a social platform for conversations, updates and community engagement. Use the Blog2Social API to connect Threads accounts, publish posts and automate social media publishing workflows.

Supported Content Types

Posts

Supported Media

Links
Images
Videos

Connect a Threads Account

Retrieve available networks using /network/list
Select the Threads network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Threads Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Threads Post",
  "message": "Hello Threads",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Threads Use Cases

Brand Communication
Community Engagement
Content Distribution
Social Media Automation
Audience Updates

Best Practices

Keep posts concise and conversational.
Use images or videos to increase visibility.
Publish content that encourages interaction.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

TikTok

Publish content to TikTok through the Blog2Social API.

TikTok is a leading platform for short-form video content, trends and audience engagement. Use the Blog2Social API to connect TikTok accounts, publish image and video content, and automate TikTok publishing workflows.

Supported Content Types

Posts

Supported Media

Images
Videos

Connect a TikTok Account

Retrieve available networks using /network/list
Select the TikTok network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a TikTok Post

Use postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "TikTok Post",
  "message": "Hello TikTok",
  "postFormat": 2,
  "mediaObjects": [
    {
      "type": "VIDEO",
      "url": "https://example.com/video.mp4"
    }
  ]
}

Common TikTok Use Cases

Short-Form Video Publishing
Product Promotion
Creator Campaigns
Brand Awareness
Social Media Automation

Best Practices

Use vertical, engaging video content.
Keep messages short and relevant.
Use strong visual hooks.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Torial

Publish content to Torial through the Blog2Social API.

Torial is a publishing platform for journalists, writers and professional content creators. Use the Blog2Social API to connect Torial accounts, publish articles and automate content distribution.

Supported Content Types

Articles

Supported Media

Images

Connect a Torial Account

Retrieve available networks using /network/list
Select the Torial network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Torial Article

Use postFormat = 1 when publishing article content with images.

Example:

{
  "client_user_network_id": 3241,
  "title": "Torial Article",
  "message": "This is the article content for Torial.",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Torial Use Cases

Article Publishing
Journalism Portfolios
Professional Content Distribution
Author Branding
Editorial Publishing

Best Practices

Use clear titles and structured article content.
Add relevant images where useful.
Keep content professional and informative.
Store the client_user_network_id for future publishing.
Reuse high-quality editorial content across publishing workflows.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Tumblr

Publish content to Tumblr through the Blog2Social API.

Tumblr is a blogging and social publishing platform for creative content, visual storytelling and community engagement. Use the Blog2Social API to connect Tumblr accounts, publish posts and automate content distribution.

Supported Content Types

Posts

Supported Media

Links
Images
Videos

Connect a Tumblr Account

Retrieve available networks using /network/list
Select the Tumblr network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Tumblr Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Tumblr Post",
  "message": "Hello Tumblr",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Common Tumblr Use Cases

Blog Content Distribution
Creative Publishing
Visual Storytelling
Community Engagement
Brand Awareness

Best Practices

Use expressive visuals and concise text.
Add relevant links where useful.
Keep content aligned with your audience.
Store the client_user_network_id for future publishing.
Monitor publishing results and engagement.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

Vimeo

Publish content to Vimeo through the Blog2Social API.

Vimeo is a video hosting platform for professional video publishing, branded content and creative media distribution. Use the Blog2Social API to connect Vimeo accounts, publish videos and automate video publishing workflows.

Supported Content Types

Videos

Supported Media

Videos

Connect a Vimeo Account

Retrieve available networks using /network/list
Select the Vimeo network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Vimeo Video

Use postFormat = 2 and provide a video URL.

Example:

{
  "client_user_network_id": 3241,
  "title": "Vimeo Video",
  "message": "Video description for Vimeo",
  "postFormat": 2,
  "mediaObjects": [
    {
      "type": "VIDEO",
      "url": "https://example.com/video.mp4"
    }
  ]
}

Common Vimeo Use Cases

Professional Video Publishing
Portfolio Distribution
Brand Video Hosting
Product Videos
Creative Content Publishing

Best Practices

Use high-quality video files.
Add clear titles and descriptions.
Validate video URLs before publishing.
Store the client_user_network_id for future publishing.
Check video publishing results after upload.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create
/video/upload
/video/check

VK (VKontakte)

Publish content to VK (VKontakte) through the Blog2Social API.

VK is a social networking platform for communities, brands and content distribution. Use the Blog2Social API to connect VK accounts, publish posts and automate social media publishing workflows.

Supported Content Types

Posts

Supported Media

Links
Images

Connect a VK Account

Retrieve available networks using /network/list
Select the VK network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a VK Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "VK Post",
  "message": "Hello VK",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common VK Use Cases

Social Media Publishing
Community Updates
Brand Communication
Content Distribution
Marketing Automation

Best Practices

Use clear and relevant messages.
Add images to increase visibility.
Keep content aligned with your audience.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

X

Publish content to X through the Blog2Social API.

X is a leading platform for real-time communication, news distribution and audience engagement. Use the Blog2Social API to connect X accounts, publish content automatically and streamline social media publishing workflows.

Supported Content Types

Posts

Supported Media

Links
Images
Videos

Connect an X Account

Retrieve available networks using /network/list
Select the X network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts or postFormat = 2 for video posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "X Post",
  "message": "Hello X",
  "postFormat": 0,
  "customUrl": "https://example.com"
}

Retrieve Post Insights

Use the Insights endpoints to retrieve engagement and performance metrics for published content.

Available endpoints:

/network/post/insights/total
/network/post/insights/graph

Common X Use Cases

News Distribution
Content Promotion
Brand Communication
Marketing Automation
Audience Engagement

Best Practices

Keep messages concise and relevant.
Use images and videos to increase engagement.
Include links to drive traffic.
Store the client_user_network_id for future publishing.
Monitor performance using Insights.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create
/network/post/insights/total
/network/post/insights/graph

Xing

Publish content to Xing through the Blog2Social API.

Xing is a professional networking platform for business communication, employer branding and professional content distribution. Use the Blog2Social API to connect Xing accounts, publish posts and automate professional publishing workflows.

Supported Content Types

Posts

Supported Media

Links
Images

Connect a Xing Account

Retrieve available networks using /network/list
Select the Xing network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Publish a Xing Post

Use postFormat = 0 for link posts, postFormat = 1 for image posts.

Example:

{
  "client_user_network_id": 3241,
  "title": "Xing Post",
  "message": "Hello Xing",
  "postFormat": 1,
  "mediaObjects": [
    {
      "type": "IMAGE",
      "url": "https://example.com/image.jpg"
    }
  ]
}

Common Xing Use Cases

Professional Content Distribution
Employer Branding
Business Communication
Company Updates
B2B Marketing

Best Practices

Share professional and relevant content.
Use clear titles and messages.
Add images where useful.
Store the client_user_network_id for future publishing.
Monitor publishing results regularly.

Related Endpoints

/network/list
/network/add
/user/auth/list
/network/post/create

YouTube

Publish content to YouTube through the Blog2Social API.

YouTube is one of the world's largest video platforms for creators, brands and businesses. Use the Blog2Social API to connect YouTube channels, publish videos and Shorts, and manage playlist-based publishing workflows.

Supported Content Types

Videos
Shorts
Playlists

Supported Media

Videos

Connect a YouTube Account

Retrieve available networks using /network/list
Select the YouTube network_id
Create an authorization link using /network/add
Redirect the user to the returned auth_link
Retrieve the connected account using /user/auth/list

Retrieve Playlists

Use /network/categories to retrieve available YouTube playlists for a connected account.

Publish a YouTube Video

Use postFormat = 2 and provide a video URL.

Example:

{
  "client_user_network_id": 3241,
  "title": "YouTube Video",
  "message": "Video description for YouTube",
  "postFormat": 2,
  "mediaObjects": [
    {
      "type": "VIDEO",
      "url": "https://example.com/video.mp4"
    }
  ]
}

Common YouTube Use Cases

Video Publishing
YouTube Shorts
Product Videos
Tutorials and Education
Brand Channels

Best Practices

Use clear titles and descriptions.
Upload high-quality video files.
Publish to the correct playlist when needed.
Store the client_user_network_id for future publishing.
Check video publishing results after upload.

Related Endpoints

/network/list
/network/add
/network/categories
/user/auth/list
/network/post/create
/video/upload
/video/check