Classify 10,000 Tweets with Jev and the X API: Real Costs

TL;DR: On 2026-09-20 we pulled 10,000 live tweets mentioning 12 brands with GetXAPI (512 calls, $0.512) and classified every one with Jev, TypeSafe's new decision model, through OpenRouter (10,000 of 10,000 succeeded, $0.2761, median 0.43s per call). Four questions per tweet: what kind of tweet it is, sentiment, spam, and buying intent. Against 200 blind reference labels Jev agreed on 83.5%, and on 93% when its own confidence was 0.9 or higher. The full script is below.

What is Jev?

Jev is a decision model from TypeSafe AI, released in September 2026. It does not write text. You send a state, such as one tweet, plus a set of typed questions, and it answers all of them in a single pass, each with a probability. That makes it a fit for classification work where an LLM is slow and expensive and a keyword filter is too blunt.

It has three question types, described in the TypeSafe docs:

Everything about Jev's speed and cost outside this post is TypeSafe's own reporting. The numbers below are ours, from one run.

The run in numbers

Two notes. Other developers have reported OpenRouter's Decisions endpoint hanging on a share of calls. We did not see that: zero timeouts in 10,001 requests. And we saw no 429 at about 26 calls per second, though that is one session and the endpoint is marked alpha.

The cost surprise: you pay for the questions, not the tweets

A tweet is 40 to 60 tokens. Our median call was 618. The shortest call in the whole run was 573 tokens, which is what the four questions and their criteria cost before any tweet text is added.

So a back-of-envelope estimate based on tweet length alone is off by about ten times. Three things follow:

• Trim the schema first. One-line criteria and fewer options cut spend almost in proportion.
• Ask everything in one call. A second call repeats the state, so four questions in one request is far cheaper than four requests.
• Watch long posts. 231 of the 10,000 tweets ran past 1,000 tokens because they were long-form posts. The largest single call was 18,401 tokens.

Even with that overhead, 10,000 tweets cost 28 cents.

Step 1: fetch the tweets

GetXAPI's advanced search returns about 20 tweets per call and a cursor for the next page. Each call is $0.001, there is no X developer account to apply for, and the query syntax is the same one X's own search uses. The advanced search operators guide covers the syntax.

import os, requests

GETXAPI_KEY = os.environ["GETXAPI_KEY"]

def fetch_tweets(query, pages=50):
    """Yield tweets for one search query, newest first, following the cursor."""
    session, cursor = requests.Session(), None
    for _ in range(pages):
        params = {"q": query, "product": "Latest"}
        if cursor:
            params["cursor"] = cursor
        r = session.get(
            "https://api.getxapi.com/twitter/tweet/advanced_search",
            headers={"Authorization": f"Bearer {GETXAPI_KEY}"},
            params=params, timeout=40)
        r.raise_for_status()
        data = r.json()
        yield from data.get("tweets", [])
        cursor = data.get("next_cursor")
        if not data.get("has_more") or not cursor:
            break

tweets, seen = [], set()
for brand in ["notion", "figma", "vercel", "supabase", "stripe"]:
    for tw in fetch_tweets(f"{brand} lang:en -filter:retweets"):
        if tw["id"] not in seen and tw.get("text"):
            seen.add(tw["id"])
            tweets.append({"id": tw["id"], "brand": brand, "text": tw["text"]})

Fifty pages per brand gives close to 1,000 tweets each. Dedupe on id, because the same post can match two queries. There is no endpoint-specific quota to plan around, though general service throttling still applies, so wrap long jobs in a retry with backoff.

Step 2: define the questions

This is the whole "model": four typed questions. The criteria text is what Jev reads to decide, so write it the way you would brief a new teammate.

QUESTIONS = {
    "kind": {
        "type": "choice",
        "instructions": "What is the author mainly doing in this tweet, with respect to the brand?",
        "criteria": {
            "praise": "recommending, celebrating or saying something positive about the brand or product",
            "complaint": "reporting a problem, a bug, a bad experience, or criticising the brand or product",
            "question": "asking how to do something, asking for help or asking for a recommendation",
            "news": "neutrally sharing news, an announcement, a tutorial or a fact",
            "promo": "advertising, selling, a giveaway, a job post, affiliate or engagement bait",
            "unrelated": "the brand word appears but the tweet is not about the product at all",
        },
    },
    "sentiment": {
        "type": "score",
        "instructions": "How does the author feel in this tweet?",
        "criteria": ["Very negative", "Negative", "Neutral", "Positive", "Very positive"],
    },
    "spam": {
        "type": "noul",
        "instructions": "This tweet is spam, a scam, automated promotion or engagement bait.",
    },
    "buying_intent": {
        "type": "noul",
        "instructions": "The author is looking for a product, tool or service to buy, try or switch to.",
    },
}

The unrelated option matters more than it looks. Search for notion and most of what comes back is the English word, not the app.

Step 3: classify with Jev through OpenRouter

Jev does not use the chat completions endpoint. OpenRouter serves it at /api/alpha/decisions, listed as typesafe/jev-1.13. It does not show up in OpenRouter's public models list, because its output type is decisions, not text.

import os, time, requests
from concurrent.futures import ThreadPoolExecutor

OPENROUTER_KEY = os.environ["OPENROUTER_API_KEY"]
URL = "https://openrouter.ai/api/alpha/decisions"

def classify(tweet, tries=4):
    body = {
        "model": "typesafe/jev-1.13",
        "state": {"brand": tweet["brand"], "tweet": tweet["text"]},
        "questions": QUESTIONS,
    }
    for attempt in range(tries):
        try:
            r = requests.post(URL, json=body, timeout=15,
                              headers={"Authorization": f"Bearer {OPENROUTER_KEY}"})
            if r.status_code == 200 and "answers" in r.json():
                return {"id": tweet["id"], **r.json()}
        except requests.exceptions.RequestException:
            pass
        time.sleep(0.5 * 2 ** attempt)      # 0.5s, 1s, 2s, 4s
    return {"id": tweet["id"], "failed": True}

with ThreadPoolExecutor(max_workers=12) as pool:
    results = list(pool.map(classify, tweets))

One real response from the run, for a tweet complaining that a hosting bill had "gotten out of hand" and asking for an alternative (probabilities rounded to two places):

{
  "model": "typesafe/jev-1.13-20260917",
  "answers": {
    "kind": {
      "type": "choice",
      "choice": "complaint",
      "probabilities": {"complaint": 0.59, "unrelated": 0, "praise": 0, "promo": 0, "question": 0.41, "news": 0},
      "confidence": 0.51
    },
    "sentiment": {
      "type": "score",
      "score": 0.79,
      "legend": {"0": "Very negative", "1": "Negative", "2": "Neutral", "3": "Positive", "4": "Very positive"},
      "probabilities": {"0": 0.21, "1": 0.79, "2": 0, "3": 0, "4": 0},
      "confidence": 0.82
    },
    "spam": {"type": "noul", "noul": 0.11},
    "buying_intent": {"type": "noul", "noul": 0.96}
  },
  "usage": {"input_tokens": 629, "output_tokens": 114, "cost": 0.000026418}
}

usage.cost is returned per call, so you can total real spend instead of estimating it. Keep the timeout and the retry even though we needed only one: the endpoint is alpha.

What 10,000 tweets look like

Nearly half of a raw brand search is noise: the word used in another sense, or promotion. Jev put 2,093 tweets at a spam score of 0.5 or higher, and 941 at a buying-intent score of 0.5 or higher.

By brand, the picture changes a lot:

Things a keyword filter cannot give you:

• 77% of notion results are not about Notion. They are people using the word "notion". A sentiment average over the raw search would be measuring politics and sport. stripe has the same problem at 34%, from clothing and beer.
• Developer tools draw praise, consumer brands draw promotion. Supabase and Vercel sit at 31% and 30% praise. Discord is 54% promotion, mostly "join my server" posts.
• Buying intent is sparse, which is why it is valuable. Filtering to buying intent of 0.8 or higher, spam under 0.3, and kind of question or complaint left 68 tweets out of 10,000. They read like sales leads: someone saying their hosting bill has "gotten out of hand" and asking for the best alternative, someone asking for "the best replacement" for a free tier, someone whose card keeps getting declined on a checkout they "really want to use".

That last filter is three comparisons on fields Jev already returned. No second model call.

How often is it right?

We drew 200 tweets at random (fixed seed) and had a second reviewer label the kind of each one blind, before looking at Jev's answer. For 32 tweets that were honestly ambiguous, the reviewer also wrote down a second acceptable label.

Agreement follows Jev's own confidence closely, which is the practical finding:

So the confidence number is usable as a gate. Act automatically above 0.9, and queue the rest for a person or a slower model.

Read this table for what it is. The reference labels came from one LLM reviewer in a single pass, not from a panel of humans. It measures agreement between two labellers, and the categories overlap by nature (a tip that mentions a product can be news or praise). It is not ground-truth accuracy.

Where it went wrong

By category, Jev caught every tweet the reviewer called complaint (16 of 16) and promo (34 of 34). The misses were concentrated in unrelated (47 of 64) and news (44 of 56). The common thread is that when the brand word is incidental, Jev still reads the tone of the sentence and files it as praise or complaint. Two fixes worth testing: add a separate noul question, "This tweet is about the software product named in brand", and gate on it first; and add a line to the criteria for slang your audience uses.

When to use this, and when not to

If you would rather stay with open-source models and no third-party classifier, the Python sentiment analysis tutorial runs TextBlob, VADER and a RoBERTa model on the same kind of data. For pulling tweets by tag instead of by brand, see searching tweets by hashtag.

Reproduce it

• A GetXAPI key: sign up, new accounts get free credits and no card is needed. 10,000 tweets is about 500 calls.
• An OpenRouter key with a dollar of credit. The classification costs cents.
• The three code blocks above, in order. Set GETXAPI_KEY and OPENROUTER_API_KEY in your environment.

Swap the brand list for your own product and your competitors, and the question set for what your team actually needs to know. The cost scales with the length of your questions, not with how many tweets you read.

Related Reading

• Twitter advanced search operators, every operator you can put in the q parameter
• Twitter sentiment analysis in Python, the open-source route with TextBlob, VADER and RoBERTa
• Search tweets by hashtag with the X API, tested hashtag queries and the cursor loop
• Twitter API rate limits, how throttling works and how to back off
• GetXAPI pricing, the per-call price list