DEV Community: Lautner

How to Post Tweets via API Without a Developer Account

Lautner — Mon, 22 Jun 2026 08:02:44 +0000

How to Post Tweets via API Without a Developer Account

  June 20, 20268 min read

  If you've ever tried to post tweets programmatically, you know the frustration. The official Twitter Developer Portal requires an application, approval process, and often a paid plan just to write tweets. For many developers and small projects, this barrier is too high.

  There's a simpler way. In this guide, we'll show you how to post tweets via a REST API without needing a Twitter Developer account at all.

  ## Why the Twitter Developer Portal Is a Problem

  The official Twitter API (now X API) has three tiers:


    - **Free tier** — Read-only access. You cannot post tweets.

    - **Basic tier ($100/month)** — Write access, but limited to 3,000 tweets per month.

    - **Pro tier ($5,000/month)** — Full access with higher limits.



  For a side project, bot, or startup, $100/month just to post tweets is expensive. And the approval process can take days or weeks.

  ## The Alternative: Cookie-Based API Access

  Instead of using the official developer API, you can use the same endpoints that the Twitter web app uses. When you log into Twitter in your browser, it creates a session with two cookies:


    - **auth_token** — Your session identifier

    - **ct0** — Your CSRF token



  These cookies let you call the same internal GraphQL endpoints that the Twitter website uses. No developer account needed.

  ## Step-by-Step: Post Your First Tweet

  ### 1. Create a ChirpAPI Account
  Sign up at [chirpapi.fun/register](https://chirpapi.fun/register). No credit card required. You get 30 free actions to start.

  ### 2. Connect Your Twitter Account
  In your browser, log into Twitter. Open DevTools (F12), go to Application > Cookies, and copy your `auth_token` and `ct0` values. Paste them into ChirpAPI's account connection form.

  ### 3. Get Your API Key
  Go to the API Keys tab in your dashboard and generate a key. It starts with `tf_` and looks like: `tf_aBcDeFgHiJkLmNoPqRsTuVwXyZ012345`

  ### 4. Post a Tweet
  Send a POST request:

curl -X POST https://api.chirpapi.fun/v1/tweet \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from ChirpAPI!"}'

# Response (200 OK)
{
  "id": "1928374650123456789",
  "text": "Hello from ChirpAPI!",
  "created_at": "2026-06-19T10:00:00Z"
}

  ### 5. Use It in Your Code

import requests

response = requests.post(
    "https://api.chirpapi.fun/v1/tweet",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text": "Posted from Python!"}
)

print(response.json())
# {'id': '1928374650123456789', 'text': 'Posted from Python!', ...}

  ## What Else Can You Do?

  With ChirpAPI, you can do more than just post tweets:


    - **Delete tweets** — `DELETE /v1/tweet/{id}`

    - **Like/unlike** — `POST /v1/like` / `POST /v1/unlike`

    - **Retweet/unretweet** — `POST /v1/retweet` / `POST /v1/unretweet`

    - **Reply** — `POST /v1/reply`

    - **Follow/unfollow** — `POST /v1/follow` / `POST /v1/unfollow`

    - **Read timeline** — `GET /v1/timeline`



  ## Is This Safe?

  ChirpAPI uses the same endpoints as the Twitter web app itself. However, there are risks:


    - Twitter can detect unusual API usage patterns

    - Rapid-fire actions can trigger rate limits or suspensions

    - New accounts should "warm up" before heavy automation



  We recommend starting slow: a few actions per day, then gradually increasing. See our [documentation](/docs) for warm-up schedules and safe limits.

Originally published at ChirpAPI Blog.

How to Schedule Tweets with a REST API

Lautner — Mon, 22 Jun 2026 07:56:28 +0000

How to Schedule Tweets with a REST API

  June 16, 20267 min read

  Scheduling tweets is one of the most common automation use cases. You write your content ahead of time, set a time, and the API posts it for you. No manual action needed. Here's how to build it with ChirpAPI and a few lines of code.

  ## Basic Concept

  The approach is simple: store your tweets with a scheduled time, run a cron job every minute, and post any tweets whose time has arrived. The flow looks like this:


    - You (or your app) save a tweet with a `scheduled_at` timestamp

    - A cron job runs every minute

    - It checks for tweets where `scheduled_at > /var/log/tweet-scheduler.log 2>&1

`plaintext

  ## Node.js Implementation

`
const sqlite3 = require('better-sqlite3');
const fetch = require('node-fetch');

const API_KEY = 'YOUR_CHIRPAPI_KEY';
const db = sqlite3('scheduler.db');

async function postPending() {
const now = new Date().toISOString().slice(0, 19);
const pending = db.prepare(
SELECT id, text FROM tweets WHERE status='pending' AND scheduled_at<=?
).all(now);

for (const {id, text} of pending) {
try {
const res = await fetch('https://api.chirpapi.fun/v1/tweet', {
method: 'POST',
headers: {
'Authorization': Bearer ${API_KEY},
'Content-Type': 'application/json'
},
body: JSON.stringify({text})
});

  if (res.ok) {
    db.prepare(`UPDATE tweets SET status='posted' WHERE id=?`).run(id);
    console.log(`Posted: ${text.slice(0, 50)}...`);
  } else {
    db.prepare(`UPDATE tweets SET status='failed' WHERE id=?`).run(id);
  }
} catch (err) {
  db.prepare(`UPDATE tweets SET status='error' WHERE id=?`).run(id);
}

}
}

postPending();
`plaintext

  ## Timezone Handling

  Always store and compare times in UTC. Convert to the user's timezone only for display:

`
from zoneinfo import ZoneInfo

User says "post at 9 AM Jakarta time"

jakarta = ZoneInfo("Asia/Jakarta")
scheduled = datetime(2026, 6, 17, 9, 0, 0, tzinfo=jakarta)
utc_time = scheduled.astimezone(timezone.utc)

Store utc_time in database

`plaintext

  ## Best Posting Times

  Based on engagement data across multiple accounts:


    - **Weekdays:** 8-10 AM and 12-1 PM (user's timezone)

    - **Weekends:** 10 AM - 12 PM

    - **Avoid:** After 8 PM (lower engagement)

    - **Best days:** Tuesday, Wednesday, Thursday



  ## Error Handling and Retries

  Network requests fail. Add retry logic:

`
import time

def post_with_retry(text, max_retries=3):
for attempt in range(max_retries):
try:
resp = requests.post(API_URL,
headers={"Authorization": f"Bearer {API_KEY}"},
json={"text": text},
timeout=10
)
if resp.status_code == 200:
return resp.json()
if resp.status_code == 429: # Rate limited
time.sleep(60 * (attempt + 1))
continue
return None
except requests.exceptions.Timeout:
time.sleep(5 * (attempt + 1))
return None
`

Originally published at ChirpAPI Blog.

Auto-Like Tweets: A Developer's Guide to Automated Engagement

Lautner — Mon, 22 Jun 2026 07:56:12 +0000

Auto-Like Tweets: A Developer's Guide to Automated Engagement

  June 18, 20266 min read

  Liking tweets is the simplest form of engagement on Twitter. It costs nothing, takes a second, and puts your name in front of the tweet author. Automating this process — liking tweets that match specific keywords — is one of the most effective growth tactics for new accounts. Here's how to build it.

  ## How It Works

  The flow is straightforward:


    - Search for tweets matching your target keywords

    - Filter out tweets you've already liked

    - Like each remaining tweet via the API

    - Log what you liked to avoid duplicates

    - Repeat on a schedule



  ## Python Implementation

import requests
import time
import sqlite3

API_KEY = "YOUR_CHIRPAPI_KEY"
BASE_URL = "https://api.chirpapi.fun/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# Keywords to target
KEYWORDS = ["python programming", "web development", "startup"]

db = sqlite3.connect("engagement.db")
db.execute("""CREATE TABLE IF NOT EXISTS liked_tweets (
    tweet_id TEXT PRIMARY KEY,
    liked_at TEXT DEFAULT CURRENT_TIMESTAMP
)""")

def is_already_liked(tweet_id):
    row = db.execute(
        "SELECT 1 FROM liked_tweets WHERE tweet_id=?", (tweet_id,)
    ).fetchone()
    return row is not None

def search_and_like():
    for keyword in KEYWORDS:
        # Search for tweets
        search_resp = requests.get(
            f"{BASE_URL}/search",
            headers=HEADERS,
            params={"q": keyword, "count": 10},
            timeout=10
        )

        if search_resp.status_code != 200:
            print(f"Search failed for '{keyword}': {search_resp.status_code}")
            continue

        tweets = search_resp.json().get("tweets", [])
        print(f"Found {len(tweets)} tweets for '{keyword}'")

        for tweet in tweets:
            tweet_id = tweet["id"]

            if is_already_liked(tweet_id):
                continue

            # Like the tweet
            like_resp = requests.post(
                f"{BASE_URL}/like",
                headers=HEADERS,
                json={"tweet_id": tweet_id},
                timeout=10
            )

            if like_resp.status_code == 200:
                db.execute("INSERT OR IGNORE INTO liked_tweets (tweet_id) VALUES (?)", (tweet_id,))
                db.commit()
                print(f"Liked: {tweet.get('text', '')[:60]}...")
            elif like_resp.status_code == 429:
                print("Rate limited. Waiting 60 seconds...")
                time.sleep(60)
            else:
                print(f"Like failed: {like_resp.status_code}")

            # Random delay between likes (30-90 seconds)
            time.sleep(random.randint(30, 90))

search_and_like()

  ## Node.js Implementation

const fetch = require('node-fetch');
const sqlite3 = require('better-sqlite3');

const API_KEY = 'YOUR_CHIRPAPI_KEY';
const BASE = 'https://api.chirpapi.fun/v1';
const db = sqlite3('engagement.db');

db.exec(`CREATE TABLE IF NOT EXISTS liked_tweets (
  tweet_id TEXT PRIMARY KEY,
  liked_at TEXT DEFAULT CURRENT_TIMESTAMP
)`);

const KEYWORDS = ['javascript', 'react', 'webdev'];

async function searchAndLike() {
  for (const keyword of KEYWORDS) {
    const searchRes = await fetch(
      `${BASE}/search?q=${encodeURIComponent(keyword)}&count=10`,
      {headers: {'Authorization': `Bearer ${API_KEY}`}}
    );
    if (!searchRes.ok) continue;

    const {tweets} = await searchRes.json();

    for (const tweet of tweets) {
      const already = db.prepare(
        'SELECT 1 FROM liked_tweets WHERE tweet_id=?'
      ).get(tweet.id);
      if (already) continue;

      const likeRes = await fetch(`${BASE}/like`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({tweet_id: tweet.id})
      });

      if (likeRes.ok) {
        db.prepare('INSERT OR IGNORE INTO liked_tweets VALUES (?)').run(tweet.id);
        console.log(`Liked: ${tweet.text.slice(0, 60)}...`);
      }

      // Wait 30-90 seconds between likes
      await new Promise(r => setTimeout(r, 30000 + Math.random() * 60000));
    }
  }
}

searchAndLike();

  ## Rate Limit Handling

  Twitter enforces rate limits. ChirpAPI forwards these limits. Key rules:


    - **Likes:** ~300 per 15 minutes (official limit). Stay well under.

    - **Search:** ~180 per 15 minutes.

    - **Safe target:** 50-100 likes per hour for warm accounts, 20-30 for new accounts.



  Always handle 429 responses with exponential backoff:

def like_with_backoff(tweet_id, max_retries=3):
    for attempt in range(max_retries):
        resp = requests.post(
            f"{BASE_URL}/like",
            headers=HEADERS,
            json={"tweet_id": tweet_id},
            timeout=10
        )
        if resp.status_code == 200:
            return True
        if resp.status_code == 429:
            wait = 60 * (2 ** attempt)  # 60s, 120s, 240s
            print(f"Rate limited. Waiting {wait}s...")
            time.sleep(wait)
        else:
            break
    return False

  ## Safety: Account Warm-Up Schedule

  New accounts should not start with heavy automation. Twitter watches for sudden spikes in activity.


    - **Week 1:** 5-10 likes per day, spread across 8+ hours

    - **Week 2:** 15-25 likes per day

    - **Week 3:** 30-50 likes per day

    - **Week 4+:** 50-100 likes per day (if no warnings)



  If you receive a "your account looks automated" warning, stop all automation for 48 hours, then resume at half the previous rate.

  ## Keyword Selection Tips


    - **Be specific:** "python async" is better than "programming"

    - **Use quotes:** Search for exact phrases to reduce noise

    - **Exclude retweets:** Add `-filter:retweets` to your search query

    - **Target recent:** Add `since:2026-06-15` to avoid old tweets

    - **Filter by engagement:** `min_faves:5` to skip tweets nobody cares about

Originally published at ChirpAPI Blog.

ChirpAPI vs Twitter Developer Portal: A Practical Comparison

Lautner — Mon, 22 Jun 2026 07:46:38 +0000

ChirpAPI vs Twitter Developer Portal: A Practical Comparison

  June 12, 20269 min read

  If you need to post tweets programmatically, you have two real options: go through the official Twitter Developer Portal, or use an alternative API like ChirpAPI. This is not a marketing pitch — it's a practical breakdown of what each option costs, what you get, and when it makes sense to choose one over the other.

  ## The Official Twitter API Tiers

  Twitter (now X) offers three API tiers as of 2026:

  | Tier | Cost | Write Access | Rate Limit | Approval |

| --- | --- | --- | --- | --- |
| Free | $0/mo | No (read-only) | 1,500 reads/mo | Instant |
| Basic | $100/mo | Yes | 3,000 tweets/mo | 1-7 days |
| Pro | $5,000/mo | Yes | 300,000 tweets/mo | 1-14 days |

  The Free tier is read-only — you cannot post tweets, like, retweet, or follow anyone. If you want write access, the minimum is $100/month for the Basic tier.

  ## What ChirpAPI Offers

  | Plan | Cost | Actions | Approval |

| --- | --- | --- | --- |
| Free | $0 | 30/lifetime | Instant |
| Starter | $9/mo | 1,000/mo | Instant |
| Pro | $29/mo | 10,000/mo | Instant |
| Agency | $99/mo | 50,000/mo | Instant |

  Every plan includes all actions: tweet, retweet, like, follow, unfollow, reply, delete, search, and timeline read. No feature gating by tier.

  ## Cost Comparison: Real Scenarios

  ### Scenario 1: Side Project (50 tweets/month)

    - **Twitter API:** Basic tier — $100/month for 3,000 tweet capacity. You use 50. That's $2 per tweet.

    - **ChirpAPI:** Starter plan — $9/month for 1,000 actions. That's $0.009 per tweet.



  ### Scenario 2: Growth Bot (2,000 actions/month)

    - **Twitter API:** Basic tier — $100/month. You hit the 3,000 tweet cap and also need likes/follows which cost additional quota.

    - **ChirpAPI:** Pro plan — $29/month. All 2,000 actions covered. That's $0.0145 per action.



  ### Scenario 3: Agency Managing Multiple Accounts (20,000 actions/month)

    - **Twitter API:** Pro tier — $5,000/month. Required because Basic caps at 3,000.

    - **ChirpAPI:** Agency plan — $99/month. That's $0.005 per action.



  ## Beyond Cost: What Else Differs

  ### Approval Process
  The Twitter Developer Portal requires you to describe your use case, provide a website, and wait for manual review. Rejections are common — many developers report being rejected multiple times before getting approved.

  ChirpAPI has no approval process. You sign up, get an API key, and start making requests.

  ### Authentication
  The official API uses OAuth 2.0 with PKCE. You need to register an application, manage client IDs and secrets, handle token refresh flows, and implement callback URLs.

  ChirpAPI uses a simple Bearer token. One header, one key:

// ChirpAPI — one header
curl -X POST https://api.chirpapi.fun/v1/tweet \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"text": "Hello world"}'

  ### Account Requirements
  The official API requires a verified Twitter Developer account. Some features require a linked credit card even on the Free tier.

  ChirpAPI requires a Twitter account (for the tweets to be posted from) but no developer account. You connect your existing Twitter session.

  ## When to Use the Official API

  The official Twitter API is the right choice when:


    - You're building an enterprise application that needs guaranteed uptime SLAs directly from X

    - You need access to the full Firehose or Academic Research endpoints

    - Your company requires SOC 2 compliance from all API providers

    - You need to read at scale (millions of tweets per month for data analysis)

    - Budget is not a constraint and you value the "official" label



  ## When to Use ChirpAPI

  ChirpAPI is the better choice when:


    - You need write access (post, like, retweet, follow) without paying $100+/month

    - You're building a side project, bot, or MVP

    - You want to start immediately without waiting for approval

    - You need a simple REST API without OAuth complexity

    - You're an agency managing multiple accounts and need volume pricing



  ## Side-by-Side: Posting a Tweet

  ### Official Twitter API (Python)

import tweepy

# Requires OAuth 2.0 setup with client ID/secret
client = tweepy.Client(
    consumer_key="YOUR_CONSUMER_KEY",
    consumer_secret="YOUR_CONSUMER_SECRET",
    access_token="YOUR_ACCESS_TOKEN",
    access_token_secret="YOUR_ACCESS_TOKEN_SECRET"
)

response = client.create_tweet(text="Hello world")
print(response.data["id"])

  ### ChirpAPI (Python)

import requests

# One API key, one header
response = requests.post(
    "https://api.chirpapi.fun/v1/tweet",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text": "Hello world"}
)

print(response.json()["id"])

  Both achieve the same result. The difference is setup time, cost, and complexity.

Originally published at ChirpAPI Blog. Try ChirpAPI — 30 free actions, no approval needed.

Twitter API Alternatives in 2026: What Actually Works

Lautner — Mon, 22 Jun 2026 07:46:34 +0000

Twitter API Alternatives in 2026: What Actually Works

  June 14, 202610 min read

  The official Twitter API is expensive and slow to get approved. So developers have built alternatives. Some work well. Some are broken. Some are outright scams. This is an honest breakdown of every option available in 2026.

  ## Option 1: The Official Twitter/X API

  The obvious starting point. The official API is reliable, well-documented, and guaranteed to work. The problem is cost and access:


    - **Free tier:** Read-only. 1,500 tweets/month read. Cannot write.

    - **Basic ($100/mo):** Write access. 3,000 tweets/month. 1-7 day approval.

    - **Pro ($5,000/mo):** Full access. 300,000 tweets/month. 1-14 day approval.



  Verdict: Works perfectly if you can afford it and get approved. Most side projects and bots cannot justify $100/month just to post tweets.

  ## Option 2: Browser Automation (Puppeteer / Playwright)

  You can automate a real browser to log into Twitter and perform actions. This is how many early Twitter bots worked.

// Puppeteer example — automated tweet
const browser = await puppeteer.launch({headless: true});
const page = await browser.newPage();

await page.goto('https://x.com/login');
await page.type('input[name="text"]', 'your_email');
await page.click('[data-testid="LoginForm_Login_Button"]');
// ... more steps for password, 2FA, etc.

await page.goto('https://x.com/compose/tweet');
await page.type('[data-testid="tweetTextarea_0"]', 'Hello from Puppeteer');
await page.click('[data-testid="tweetButton"]');

  Verdict: Extremely slow (5-15 seconds per action), fragile (Twitter changes their DOM frequently), resource-heavy (needs a full browser), and easy to detect. Not recommended for production.

  ## Option 3: Scraping Libraries (twikit, snscrape)

  Python libraries like `twikit` and `snscrape` reverse-engineer Twitter's internal API. They use your session cookies to make requests directly.

# twikit example
from twikit import Client

client = Client()
await client.login(
    auth_info_1="your_email",
    password="your_password"
)
await client.create_tweet("Hello from twikit")

  Verdict: Works for personal scripts and one-off tasks. Not suitable for multi-user platforms because you'd need to manage hundreds of sessions. Libraries break when Twitter changes their internal API (which happens every few weeks).

  ## Option 4: Cookie-Based API Services (ChirpAPI)

  Services like ChirpAPI take a different approach: they use Twitter's own internal GraphQL endpoints, authenticated with your session cookies, wrapped behind a clean REST API.

# ChirpAPI — works like any REST API
curl -X POST https://api.chirpapi.fun/v1/tweet \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from ChirpAPI"}'

# Response in ~200ms
{"id": "1928374650123456789", "text": "Hello from ChirpAPI"}

  Verdict: Fast (~200ms per action), reliable (uses the same endpoints as the Twitter web app), and affordable ($9-99/month). The trade-off is that Twitter can change their internal endpoints, but service providers update their implementations quickly.

  ## Option 5: Nitter / RSS-Based Scraping

  Nitter was an open-source Twitter frontend that scraped public profiles. As of 2026, most Nitter instances are defunct — Twitter blocked the scraping methods they relied on.

  Verdict: Dead for write operations. Was only ever useful for reading public profiles anyway.

  ## Comparison Table

  | Method | Cost | Speed | Reliability | Write Access | Multi-Account |

| --- | --- | --- | --- | --- | --- |
| Official API | $100-5,000/mo | Fast | Excellent | Yes | Yes |
| Puppeteer | Free (self-hosted) | Slow | Fragile | Yes | Hard |
| twikit/sns | Free | Medium | Breaks often | Yes | No |
| ChirpAPI | $9-99/mo | Fast | Good | Yes | Yes |
| Nitter | Free | N/A | Dead | No | N/A |

  ## Which Should You Use?


    - **Enterprise with budget:** Official API. You get SLAs, support, and guaranteed stability.

    - **Personal script / one-off:** twikit. Free, works for simple use cases.

    - **Production bot / SaaS / agency:** ChirpAPI or similar service. Best balance of cost, speed, and reliability.

    - **Data collection (read-only):** Official API Free tier or academic research access.

Originally published at ChirpAPI Blog. Try ChirpAPI — 30 free actions, no approval needed.