List Posts

GET https://api.postpost.dev/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.postpost.dev/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-api-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.postpost.dev/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-api-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 PostPost 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.postpost.dev/api/v1/list-posts'
    headers = {'x-api-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.postpost.dev/api/v1/list-posts',
        headers={'x-api-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.postpost.dev/api/v1',
    headers: { 'x-api-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.postpost.dev/api/v1/list-posts?page=1&limit=20&status=scheduled" \
  -H "x-api-key: YOUR_API_KEY"

# Get second page
curl "https://api.postpost.dev/api/v1/list-posts?page=2&limit=20&status=scheduled" \
  -H "x-api-key: YOUR_API_KEY"

# Filter by platform and date range
curl "https://api.postpost.dev/api/v1/list-posts?status=scheduled&platform=twitter&fromDate=2026-03-01T00:00:00Z&toDate=2026-03-31T23:59:59Z" \
  -H "x-api-key: YOUR_API_KEY"

# Get all posts sorted by scheduled time
curl "https://api.postpost.dev/api/v1/list-posts?sortBy=scheduledTime&sortOrder=asc&limit=100" \
  -H "x-api-key: YOUR_API_KEY"

#!/bin/bash

API_KEY="YOUR_API_KEY"
BASE_URL="https://api.postpost.dev/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-api-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