List Posts

GET https://api.publora.com/api/v1/list-posts

{
  "success": true,
  "posts": [
    {
      "postGroupId": "507f1f77bcf86cd799439011",
      "content": "Excited to share our new product launch!",
      "status": "scheduled",
      "scheduledTime": "2026-03-15T14:30:00.000Z",
      "createdAt": "2026-03-10T09:00:00.000Z",
      "updatedAt": "2026-03-10T09:00:00.000Z",
      "platforms": [
        {
          "platformId": "twitter-123456789",
          "platform": "twitter",
          "status": "scheduled"
        },
        {
          "platformId": "linkedin-ABC123",
          "platform": "linkedin",
          "status": "scheduled"
        }
      ],
      "mediaUrls": ["https://your-media-url.example.com/images/abc123.jpg"]
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 20,
    "totalItems": 47,
    "totalPages": 3,
    "hasNextPage": true,
    "hasPrevPage": false
  }
}

async function fetchAllScheduledPosts(apiKey) {
  const posts = [];
  let page = 1;
  let hasMore = true;
 
  while (hasMore) {
    const url = new URL('https://api.publora.com/api/v1/list-posts');
    url.searchParams.set('page', page);
    url.searchParams.set('limit', 100);
    url.searchParams.set('status', 'scheduled');
    url.searchParams.set('sortBy', 'scheduledTime');
    url.searchParams.set('sortOrder', 'asc');
 
    const response = await fetch(url, {
      headers: { 'x-publora-key': apiKey }
    });
    const data = await response.json();
 
    posts.push(...data.posts);
    hasMore = data.pagination.hasNextPage;
    page++;
 
    console.log(`Fetched page ${data.pagination.page} of ${data.pagination.totalPages}`);
  }
 
  console.log(`Total scheduled posts: ${posts.length}`);
  return posts;
}
 
// Usage
const scheduledPosts = await fetchAllScheduledPosts('YOUR_API_KEY');

class PostListPaginator {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.publora.com/api/v1/list-posts';
    this.currentPage = 1;
    this.limit = 20;
    this.filters = {};
  }
 
  setFilters({ status, platform, fromDate, toDate }) {
    this.filters = { status, platform, fromDate, toDate };
    this.currentPage = 1; // Reset to first page when filters change
  }
 
  async fetchPage(page = this.currentPage) {
    const url = new URL(this.baseUrl);
    url.searchParams.set('page', page);
    url.searchParams.set('limit', this.limit);
 
    // Apply filters
    if (this.filters.status) url.searchParams.set('status', this.filters.status);
    if (this.filters.platform) url.searchParams.set('platform', this.filters.platform);
    if (this.filters.fromDate) url.searchParams.set('fromDate', this.filters.fromDate);
    if (this.filters.toDate) url.searchParams.set('toDate', this.filters.toDate);
 
    const response = await fetch(url, {
      headers: { 'x-publora-key': this.apiKey }
    });
    const data = await response.json();
 
    this.currentPage = data.pagination.page;
    return data;
  }
 
  async nextPage() {
    return this.fetchPage(this.currentPage + 1);
  }
 
  async prevPage() {
    return this.fetchPage(Math.max(1, this.currentPage - 1));
  }
 
  async goToPage(page) {
    return this.fetchPage(page);
  }
}
 
// Usage
const paginator = new PostListPaginator('YOUR_API_KEY');
 
// Get first page of scheduled posts
paginator.setFilters({ status: 'scheduled' });
const firstPage = await paginator.fetchPage();
 
console.log(`Showing ${firstPage.posts.length} of ${firstPage.pagination.totalItems} posts`);
 
// Navigate pages
if (firstPage.pagination.hasNextPage) {
  const secondPage = await paginator.nextPage();
}

import requests
from typing import Generator, Dict, Any, Optional
 
def fetch_posts_paginated(
    api_key: str,
    status: Optional[str] = None,
    platform: Optional[str] = None,
    limit: int = 100
) -> Generator[Dict[str, Any], None, None]:
    """
    Generator that yields posts one by one, handling pagination automatically.
 
    Args:
        api_key: Your Publora API key
        status: Filter by status (draft, scheduled, published, failed, partially_published)
        platform: Filter by platform (twitter, linkedin, etc.)
        limit: Items per page (max 100)
 
    Yields:
        Individual post objects
    """
    base_url = 'https://api.publora.com/api/v1/list-posts'
    headers = {'x-publora-key': api_key}
    page = 1
 
    while True:
        params = {
            'page': page,
            'limit': limit,
            'sortBy': 'scheduledTime',
            'sortOrder': 'asc'
        }
 
        if status:
            params['status'] = status
        if platform:
            params['platform'] = platform
 
        response = requests.get(base_url, headers=headers, params=params)
        response.raise_for_status()
        data = response.json()
 
        for post in data['posts']:
            yield post
 
        if not data['pagination']['hasNextPage']:
            break
 
        page += 1
 
 
def fetch_all_scheduled_posts(api_key: str) -> list:
    """Fetch all scheduled posts into a list."""
    posts = list(fetch_posts_paginated(api_key, status='scheduled'))
    print(f"Fetched {len(posts)} scheduled posts")
    return posts
 
 
# Usage
api_key = 'YOUR_API_KEY'
 
# Iterate through all scheduled posts
for post in fetch_posts_paginated(api_key, status='scheduled'):
    print(f"{post['postGroupId']}: {post['content'][:50]}...")
    print(f"  Scheduled for: {post['scheduledTime']}")
    print(f"  Platforms: {[p['platform'] for p in post['platforms']]}")
 
# Or fetch all at once
all_posts = fetch_all_scheduled_posts(api_key)

import requests
from datetime import datetime, timedelta, timezone
 
def get_posts_for_week(api_key: str, start_date: datetime) -> list:
    """Get all posts scheduled for a specific week."""
    end_date = start_date + timedelta(days=7)
 
    params = {
        'status': 'scheduled',
        'fromDate': start_date.isoformat(),
        'toDate': end_date.isoformat(),
        'sortBy': 'scheduledTime',
        'sortOrder': 'asc',
        'limit': 100
    }
 
    response = requests.get(
        'https://api.publora.com/api/v1/list-posts',
        headers={'x-publora-key': api_key},
        params=params
    )
 
    return response.json()['posts']
 
 
# Usage: Get posts scheduled for next week
next_monday = datetime.now(timezone.utc).replace(
    hour=0, minute=0, second=0, microsecond=0
)
# Adjust to next Monday
days_until_monday = (7 - next_monday.weekday()) % 7
next_monday += timedelta(days=days_until_monday)
 
posts = get_posts_for_week('YOUR_API_KEY', next_monday)
print(f"Posts scheduled for next week: {len(posts)}")

const axios = require('axios');
 
async function* paginatedPosts(apiKey, options = {}) {
  const { status, platform, limit = 100 } = options;
  let page = 1;
  let hasMore = true;
 
  const api = axios.create({
    baseURL: 'https://api.publora.com/api/v1',
    headers: { 'x-publora-key': apiKey }
  });
 
  while (hasMore) {
    const params = { page, limit, sortBy: 'scheduledTime', sortOrder: 'asc' };
    if (status) params.status = status;
    if (platform) params.platform = platform;
 
    const { data } = await api.get('/list-posts', { params });
 
    for (const post of data.posts) {
      yield post;
    }
 
    hasMore = data.pagination.hasNextPage;
    page++;
  }
}
 
// Usage
(async () => {
  // Iterate through all scheduled posts
  for await (const post of paginatedPosts('YOUR_API_KEY', { status: 'scheduled' })) {
    console.log(`${post.postGroupId}: ${post.content.slice(0, 50)}...`);
    console.log(`  Scheduled: ${post.scheduledTime}`);
  }
})();

# Get first page of scheduled posts
curl "https://api.publora.com/api/v1/list-posts?page=1&limit=20&status=scheduled" \
  -H "x-publora-key: YOUR_API_KEY"
 
# Get second page
curl "https://api.publora.com/api/v1/list-posts?page=2&limit=20&status=scheduled" \
  -H "x-publora-key: YOUR_API_KEY"
 
# Filter by platform and date range
curl "https://api.publora.com/api/v1/list-posts?status=scheduled&platform=twitter&fromDate=2026-03-01T00:00:00Z&toDate=2026-03-31T23:59:59Z" \
  -H "x-publora-key: YOUR_API_KEY"
 
# Get all posts sorted by scheduled time
curl "https://api.publora.com/api/v1/list-posts?sortBy=scheduledTime&sortOrder=asc&limit=100" \
  -H "x-publora-key: YOUR_API_KEY"

#!/bin/bash
 
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.publora.com/api/v1/list-posts"
PAGE=1
LIMIT=100
ALL_POSTS="[]"
 
while true; do
  RESPONSE=$(curl -s "${BASE_URL}?page=${PAGE}&limit=${LIMIT}&status=scheduled" \
    -H "x-publora-key: ${API_KEY}")
 
  POSTS=$(echo "$RESPONSE" | jq '.posts')
  HAS_NEXT=$(echo "$RESPONSE" | jq '.pagination.hasNextPage')
  TOTAL=$(echo "$RESPONSE" | jq '.pagination.totalItems')
 
  # Merge posts
  ALL_POSTS=$(echo "$ALL_POSTS" "$POSTS" | jq -s 'add')
 
  echo "Fetched page $PAGE (Total items: $TOTAL)"
 
  if [ "$HAS_NEXT" = "false" ]; then
    break
  fi
 
  PAGE=$((PAGE + 1))
done
 
echo "Total posts fetched: $(echo "$ALL_POSTS" | jq 'length')"
echo "$ALL_POSTS" > scheduled_posts.json