postiz

postiz auth:status

# 1. Authenticate
postiz auth:status
# If not authenticated: postiz auth:login --client-id <id> --client-secret <secret>
 
# 2. Discover
postiz integrations:list
postiz integrations:settings <integration-id>
 
# 3. Fetch (if needed)
postiz integrations:trigger <integration-id> <method> -d '{"key":"value"}'
 
# 4. Prepare
postiz upload image.jpg
 
# 5. Post
postiz posts:create -c "Content" -m "image.jpg" -i "<integration-id>"
 
# 6. Analyze
postiz analytics:platform <integration-id> -d 30
postiz analytics:post <post-id> -d 7
 
# 7. Resolve (if analytics returns {"missing": true})
postiz posts:missing <post-id>
postiz posts:connect <post-id> --release-id "<content-id>"

# Login via device flow (opens browser, no client ID/secret needed)
postiz auth:login
 
# Check auth status (verifies credentials are still valid)
postiz auth:status
 
# Logout (remove stored credentials)
postiz auth:logout

export POSTIZ_API_KEY=your_api_key_here

export POSTIZ_API_URL=https://custom-api-url.com

# List all connected integrations
postiz integrations:list
 
# List integrations belonging to a specific group (customer)
postiz integrations:list --group <group-id>
 
# List all groups (customers) as {id, name}
postiz integrations:groups
 
# Get settings schema for specific integration
postiz integrations:settings <integration-id>
 
# Trigger integration tool to fetch dynamic data
postiz integrations:trigger <integration-id> <method-name>
postiz integrations:trigger <integration-id> <method-name> -d '{"param":"value"}'

# Simple post (date is REQUIRED)
postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" -i "integration-id"
 
# Draft post
postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" -t draft -i "integration-id"
 
# Post with media (upload each file FIRST — see Rule 2)
IMG1=$(postiz upload img1.jpg | jq -r '.path')
IMG2=$(postiz upload img2.jpg | jq -r '.path')
postiz posts:create -c "Content" -m "$IMG1,$IMG2" -s "2024-12-31T12:00:00Z" -i "integration-id"
 
# Post with comments (each with own media — every file uploaded first)
MAIN=$(postiz upload main.jpg | jq -r '.path')
C1=$(postiz upload comment1.jpg | jq -r '.path')
C2A=$(postiz upload comment2.jpg | jq -r '.path')
C2B=$(postiz upload comment3.jpg | jq -r '.path')
postiz posts:create \
  -c "Main post" -m "$MAIN" \
  -c "First comment" -m "$C1" \
  -c "Second comment" -m "$C2A,$C2B" \
  -s "2024-12-31T12:00:00Z" \
  -i "integration-id"
 
# Multi-platform post
postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" -i "twitter-id,linkedin-id,facebook-id"
 
# Platform-specific settings
postiz posts:create \
  -c "Content" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"subreddit":[{"value":{"subreddit":"programming","title":"My Post","type":"text"}}]}' \
  -i "reddit-id"
 
# Complex post from JSON file
postiz posts:create --json post.json

# List posts (defaults to last 30 days to next 30 days)
# Each returned post includes its current `settings` (as a JSON string — JSON.parse it).
# Workflow: run posts:list to read a post's current settings, then posts:settings to patch them.
postiz posts:list
 
# List posts in date range
postiz posts:list --startDate "2024-01-01T00:00:00Z" --endDate "2024-12-31T23:59:59Z"
 
# Delete post
postiz posts:delete <post-id>
 
# Change post status (draft ↔ schedule)
postiz posts:status <post-id> --status draft     # Move back to draft, terminates any running publish workflow
postiz posts:status <post-id> --status schedule  # Promote a draft into the publishing queue (uses the post's stored date)
 
# Update a post's provider-specific settings (merged — only the keys you pass change)
# Only DRAFT/QUEUE (unpublished) posts can be updated. Pass the MAIN post id, not a comment id.
# Do NOT include __type — the backend adds it automatically from the integration.
postiz posts:settings <post-id> --settings '{"content_posting_method":"DIRECT_POST"}'   # Switch a TikTok draft to direct publishing
postiz posts:settings <post-id> --settings '{"subreddit":[{"value":{"subreddit":"/r/selfhosted","title":"My title","type":"self","is_flair_required":true}}]}'  # Set a Reddit post's subreddit

# Get platform analytics (default: last 7 days)
postiz analytics:platform <integration-id>
 
# Get platform analytics for last 30 days
postiz analytics:platform <integration-id> -d 30
 
# Get post analytics (default: last 7 days)
postiz analytics:post <post-id>
 
# Get post analytics for last 30 days
postiz analytics:post <post-id> -d 30

# 1. analytics:post returns {"missing": true}
postiz analytics:post <post-id>
 
# 2. Get available content from the provider
postiz posts:missing <post-id>
# Returns: [{"id": "7321456789012345678", "url": "https://...cover.jpg"}, ...]
 
# 3. Connect the correct content to the post
postiz posts:connect <post-id> --release-id "7321456789012345678"
 
# 4. Now analytics will work
postiz analytics:post <post-id>

# List recent content from the provider for a post with missing release ID
postiz posts:missing <post-id>
 
# Connect a post to its published content
postiz posts:connect <post-id> --release-id "<content-id>"

# Upload file and get URL
postiz upload image.jpg
 
# Supports: images (PNG, JPG, GIF, WEBP, SVG), videos (MP4, MOV, AVI, MKV, WEBM),
# audio (MP3, WAV, OGG, AAC), documents (PDF, DOC, DOCX)
 
# Workflow: Upload → Extract URL → Use in post
VIDEO=$(postiz upload video.mp4)
VIDEO_PATH=$(echo "$VIDEO" | jq -r '.path')
postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" -m "$VIDEO_PATH" -i "tiktok-id"

# Get Reddit integration ID
REDDIT_ID=$(postiz integrations:list | jq -r '.[] | select(.identifier=="reddit") | .id')
 
# Fetch available flairs
FLAIRS=$(postiz integrations:trigger "$REDDIT_ID" getFlairs -d '{"subreddit":"programming"}')
FLAIR_ID=$(echo "$FLAIRS" | jq -r '.output[0].id')
 
# Use in post
postiz posts:create \
  -c "My post content" \
  -s "2024-12-31T12:00:00Z" \
  --settings "{\"subreddit\":[{\"value\":{\"subreddit\":\"programming\",\"title\":\"Post Title\",\"type\":\"
  -i "$REDDIT_ID"

YOUTUBE_ID=$(postiz integrations:list | jq -r '.[] | select(.identifier=="youtube") | .id')
PLAYLISTS=$(postiz integrations:trigger "$YOUTUBE_ID" getPlaylists)
PLAYLIST_ID=$(echo "$PLAYLISTS" | jq -r '.output[0].id')
 
postiz posts:create \
  -c "Video description" \
  -s "2024-12-31T12:00:00Z" \
  --settings "{\"title\":\"My Video\",\"type\":\"public\",\"playlistId\":\"$PLAYLIST_ID\"}" \
  -m "video.mp4" \
  -i "$YOUTUBE_ID"

LINKEDIN_ID=$(postiz integrations:list | jq -r '.[] | select(.identifier=="linkedin") | .id')
COMPANIES=$(postiz integrations:trigger "$LINKEDIN_ID" getCompanies)
COMPANY_ID=$(echo "$COMPANIES" | jq -r '.output[0].id')
 
postiz posts:create \
  -c "Company announcement" \
  -s "2024-12-31T12:00:00Z" \
  --settings "{\"companyId\":\"$COMPANY_ID\"}" \
  -i "$LINKEDIN_ID"

# Upload multiple files
VIDEO_RESULT=$(postiz upload video.mp4)
VIDEO_PATH=$(echo "$VIDEO_RESULT" | jq -r '.path')
 
THUMB_RESULT=$(postiz upload thumbnail.jpg)
THUMB_PATH=$(echo "$THUMB_RESULT" | jq -r '.path')
 
# Use in post
postiz posts:create \
  -c "Check out my video!" \
  -s "2024-12-31T12:00:00Z" \
  -m "$VIDEO_PATH" \
  -i "tiktok-id"

# Upload every image first (Rule 2)
INTRO=$(postiz upload intro.jpg | jq -r '.path')
P1=$(postiz upload point1.jpg | jq -r '.path')
P2=$(postiz upload point2.jpg | jq -r '.path')
OUTRO=$(postiz upload outro.jpg | jq -r '.path')
 
postiz posts:create \
  -c "🧵 Thread starter (1/4)" -m "$INTRO" \
  -c "Point one (2/4)" -m "$P1" \
  -c "Point two (3/4)" -m "$P2" \
  -c "Conclusion (4/4)" -m "$OUTRO" \
  -s "2024-12-31T12:00:00Z" \
  -d 2000 \
  -i "twitter-id"

# Create JSON file with platform-specific content
cat > campaign.json << 'EOF'
{
  "integrations": ["twitter-123", "linkedin-456", "facebook-789"],
  "posts": [
    {
      "provider": "twitter",
      "post": [
        {
          "content": "Short tweet version #tech",
          "image": ["<URL returned by `postiz upload twitter-image.jpg`>"]
        }
      ]
    },
    {
      "provider": "linkedin",
      "post": [
        {
          "content": "Professional LinkedIn version with more context...",
          "image": ["<URL returned by `postiz upload linkedin-image.jpg`>"]
        }
      ]
    }
  ]
}
EOF
 
postiz posts:create --json campaign.json

#!/bin/bash
 
INTEGRATION_ID="twitter-123"
CONTENT="Your post content here"
 
# Get integration settings
SETTINGS_JSON=$(postiz integrations:settings "$INTEGRATION_ID")
MAX_LENGTH=$(echo "$SETTINGS_JSON" | jq '.output.maxLength')
 
# Provider-specific guidance written for agents. Read it and follow it — it explains
# what the settings values actually do (e.g. which enum value publishes vs. silently
# does not). Do not skip this because a field name looks self-explanatory.
echo "$SETTINGS_JSON" | jq -r '.output.rules // empty'
 
# The settings JSON schema. Property `description` fields carry the same guidance
# per-field; check them before choosing a value.
echo "$SETTINGS_JSON" | jq '.output.settings'
 
# Check character limit and truncate if needed
if [ ${#CONTENT} -gt "$MAX_LENGTH" ]; then
  echo "Content exceeds $MAX_LENGTH chars, truncating..."
  CONTENT="${CONTENT:0:$((MAX_LENGTH - 3))}..."
fi
 
# Create post with settings
postiz posts:create \
  -c "$CONTENT" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"key": "value"}' \
  -i "$INTEGRATION_ID"

#!/bin/bash
 
# Schedule posts for the week
DATES=(
  "2024-02-14T09:00:00Z"
  "2024-02-15T09:00:00Z"
  "2024-02-16T09:00:00Z"
)
 
CONTENT=(
  "Monday motivation 💪"
  "Tuesday tips 💡"
  "Wednesday wisdom 🧠"
)
 
for i in "${!DATES[@]}"; do
  # Rule 2: upload each file before passing to -m
  IMG=$(postiz upload "post-${i}.jpg" | jq -r '.path')
  postiz posts:create \
    -c "${CONTENT[$i]}" \
    -s "${DATES[$i]}" \
    -i "twitter-id" \
    -m "$IMG"
  echo "Scheduled: ${CONTENT[$i]} for ${DATES[$i]}"
done

#!/bin/bash
 
CONTENT="Your post content"
INTEGRATION_ID="twitter-123"
DATE="2024-12-31T12:00:00Z"
MAX_RETRIES=3
 
for attempt in $(seq 1 $MAX_RETRIES); do
  if postiz posts:create -c "$CONTENT" -s "$DATE" -i "$INTEGRATION_ID"; then
    echo "Post created successfully"
    break
  else
    echo "Attempt $attempt failed"
    if [ "$attempt" -lt "$MAX_RETRIES" ]; then
      DELAY=$((2 ** attempt))
      echo "Retrying in ${DELAY}s..."
      sleep "$DELAY"
    else
      echo "Failed after $MAX_RETRIES attempts"
      exit 1
    fi
  fi
done

{
  "posts": [
    {
      "provider": "reddit",
      "post": [{ "content": "...", "image": [...] }],
      "settings": {
        "__type": "reddit",
        "subreddit": [{
          "value": {
            "subreddit": "programming",
            "title": "Post Title",
            "type": "text",
            "url": "",
            "is_flair_required": false
          }
        }]
      }
    }
  ]
}

postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" --settings '{"subreddit":[...]}' -i "reddit-id"
# Backend automatically adds "__type" based on integration ID

# Upload every file first (Rule 2)
I1=$(postiz upload image1.jpg | jq -r '.path')
I2=$(postiz upload image2.jpg | jq -r '.path')
CI=$(postiz upload comment-img.jpg | jq -r '.path')
A1=$(postiz upload another.jpg | jq -r '.path')
A2=$(postiz upload more.jpg | jq -r '.path')
 
postiz posts:create \
  -c "Main post" -m "$I1,$I2" \
  -c "Comment 1" -m "$CI" \
  -c "Comment 2" -m "$A1,$A2" \
  -s "2024-12-31T12:00:00Z" \
  -d 5 \  # Delay between comments in minutes
  -i "integration-id"

{
  "posts": [{
    "value": [
      { "content": "Main post", "image": ["<uploaded image1>", "<uploaded image2>"] },
      { "content": "Comment 1", "image": ["<uploaded comment-img>"], "delay": 5 },
      { "content": "Comment 2", "image": ["<uploaded another>", "<uploaded more>"], "delay": 5 }
    ]
  }]
}

{
  "path": "https://cdn.postiz.com/uploads/abc123.jpg",
  "size": 123456,
  "type": "image/jpeg"
}

RESULT=$(postiz upload image.jpg)
PATH=$(echo "$RESULT" | jq -r '.path')
postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" -m "$PATH" -i "integration-id"

postiz posts:create -c "Content" -m "img.jpg" -i "twitter-id"

postiz posts:create --json post.json

postiz posts:create \
  -c "Post content" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"subreddit":[{"value":{"subreddit":"programming","title":"My Title","type":"text","url":"","is_flair_required":false}}]}' \
  -i "reddit-id"

# Upload video first (required!)
VIDEO=$(postiz upload video.mp4)
VIDEO_URL=$(echo "$VIDEO" | jq -r '.path')
 
postiz posts:create \
  -c "Video description" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"title":"Video Title","type":"public","tags":[{"value":"tech","label":"Tech"}]}' \
  -m "$VIDEO_URL" \
  -i "youtube-id"

# Upload video first (TikTok only accepts verified URLs!)
VIDEO=$(postiz upload video.mp4)
VIDEO_URL=$(echo "$VIDEO" | jq -r '.path')
 
postiz posts:create \
  -c "Video caption #fyp" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"privacy_level":"PUBLIC_TO_EVERYONE","duet":true,"stitch":true,"content_posting_method":"DIRECT_POST"}' \
  -m "$VIDEO_URL" \
  -i "tiktok-id"

postiz posts:create \
  -c "Tweet content" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"who_can_reply_post":"everyone"}' \
  -i "twitter-id"

# Personal post
postiz posts:create -c "Content" -s "2024-12-31T12:00:00Z" -i "linkedin-id"
 
# Company post
postiz posts:create \
  -c "Content" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"companyId":"company-123"}' \
  -i "linkedin-id"

# Upload image first (Instagram requires verified URLs!)
IMAGE=$(postiz upload image.jpg)
IMAGE_URL=$(echo "$IMAGE" | jq -r '.path')
 
# Regular post
postiz posts:create \
  -c "Caption #hashtag" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"post_type":"post"}' \
  -m "$IMAGE_URL" \
  -i "instagram-id"
 
# Story
STORY=$(postiz upload story.jpg)
STORY_URL=$(echo "$STORY" | jq -r '.path')
 
postiz posts:create \
  -c "" \
  -s "2024-12-31T12:00:00Z" \
  --settings '{"post_type":"story"}' \
  -m "$STORY_URL" \
  -i "instagram-id"