Reddit Vote API: Upvote and Downvote a Post Programmatically (2026)

Not affiliated with Reddit Inc. redditapis.com is an independent third-party REST proxy for Reddit's API.

Jump to a section:

• The Reddit Vote API in 30 seconds
• Why developers need programmatic Reddit voting in 2026
• Why Reddit write APIs got harder in 2026
• thing_id format: t3_ for posts, t1_ for comments
• Step 1: Authenticate via POST /api/reddit/login
• Step 2: Call POST /api/reddit/vote
• Common 401, 403, and 404 errors
• The direction parameter
• How to vote on Reddit without OAuth
• What happens after a vote: idempotency
• Pricing: $0.005 per vote
• Respecting Reddit community norms
• Production patterns: retry, backoff, re-login
• Using vote and comment together
• Where developers use the Reddit Vote API in production
• FAQ
• Where to go next

---

What you'll build:

• A working POST /api/reddit/vote call from curl and Python
• Auth via POST /api/reddit/login (the mandatory precondition)
• Error handling for 401, 403, and 404 responses
• Time to first vote: approximately 3 minutes from account creation

Cost: $0.005/vote + $0.012/login. Free credit: $0.50 at signup. No card required.

---

The Reddit Vote API in 30 Seconds

Two paths exist for casting votes on Reddit programmatically in 2026.

If you already have Reddit OAuth working - a registered developer app, an approved vote scope, and a refresh token - skip to Reddit's official /api/vote endpoint - the request shape is similar. No need to read further.

If you don't - or if OAuth app review has stalled, your scope request was rejected, or you want pay-per-call pricing without a $12,000/year contract - redditapis.com handles the Reddit session auth internally. You pass one bearer token from your redditapis.com account, call POST /api/reddit/login to get session cookies, then call POST /api/reddit/vote. No developer app registration. No OAuth scope review. No monthly cap.

Here is the minimal shape of that vote call:

# Minimal POST /api/reddit/vote - placeholders shown
curl -X POST https://api.redditapis.com/api/reddit/vote \
  -H "Authorization: Bearer YOUR_REDDITAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "thing_id": "t3_abc123",
    "direction": "up",
    "reddit_session": "YOUR_REDDIT_SESSION_COOKIE",
    "loid": "YOUR_LOID_COOKIE",
    "csrf_token": "YOUR_CSRF_TOKEN"
  }'

The session cookies (reddit_session, loid, csrf_token) come from a prior call to POST /api/reddit/login. Step 1 in this tutorial covers that auth flow end to end.

Use cases at a glance:

• Content creator self-upvote: vote on your own post immediately after publishing to seed early signal
• Comment-moderation tooling: upvote high-quality replies in a community you moderate
• Sentiment-action loops: vote on comments based on keyword or sentiment detection from a monitoring script
• Engagement automation: integrate votes into a broader content-workflow pipeline alongside comments and DMs

---

Why Developers Need Programmatic Reddit Voting in 2026

The question comes up constantly in r/redditdev. Developers building content pipelines, brand-monitoring tools, community-management dashboards, and engagement automation all eventually want to close the loop - not just read Reddit data, but act on it from the same script.

The use cases cluster around a few patterns: a content creator who wants to upvote their own post the moment it goes live, a developer building a moderation tool that promotes high-signal replies, or a marketer running a sentiment loop that votes on comments matching certain criteria. In every case, the ask is identical: give me a clean REST endpoint that casts a vote on behalf of my account, with predictable auth and predictable pricing.

Common developer workflows that need the vote endpoint:

• Publish a post, immediately upvote it from the same account to seed early signal
• Moderation assist: automatically upvote replies that pass a quality filter
• Sentiment loop: detect positive mentions via search, vote on them to surface them further
• Content workflow pipeline: vote + comment + DM as a coordinated single-account sequence

r/redditdev·u/billybob19eight6

New to the reddit api

Hi all, I am new to the reddit API and want to create a little app at home that can post comments, post upvotes, downvotes, etc. Current I am all squared away with my app id, secret and can obtain an access token using…

74

Open on Reddit

That thread captures the entry point accurately: developers arrive knowing they want votes, comments, and DMs from the same API, but do not know where to start. This post is the walkthrough they were looking for in 2026.

Reddit's algorithm treats early votes as a ranking signal. The first votes a post receives in the minutes after publishing carry disproportionate weight in determining whether the post reaches the top of the subreddit feed. A programmatic vote call from your own account - cast immediately after you publish - is a legitimate automation of what you would do manually if you were watching the post.

---

Why Reddit Write APIs Got Harder in 2026

As of March 31, 2026, Reddit introduced the "App" label for accounts using allowed automation - the first formal policy distinction between approved programmatic Reddit access and unwanted spam bots. Reddit's announcement on r/redditdev confirmed: accounts that use automation in allowed ways will be known as "apps" and carry a visible label. This is a recognition that programmatic Reddit use is legitimate, provided it proxies real user intent. See the Reddit Developer Platform docs for the official API reference.

r/redditdev·u/boat-botany

Keeping Reddit Human: A New App Label for Automated Accounts

As u/Spez shared last year, [Reddit works because it’s human](https://www.reddit.com/user/spez/comments/1kfciml/reddits_next_chapter_smarter_easier_still_human/). We are focused on keeping it that way and making sure…

85157

Open on Reddit

The 2026 context matters because it changed the realistic access path for write-scope API use. Reddit's June 2023 API pricing announcement moved the platform from a largely-free developer tier to a commercial model. Since then, official developer app onboarding for write scopes has been inconsistently available. What developers report about the write-scope review process as of 2026:

• Multi-week wait times for app approval in some cases
• Unclear rejection criteria with no appeal path documented
• Approval processes that stall without explanation or status update
• $12,000/year minimum for the Standard (commercial) tier once approved

The practical consequence: for most developers who need write-scope API access in 2026 and want to ship in days rather than weeks, the OAuth app review path is not reliable. A managed REST proxy that handles Reddit session auth internally - like redditapis.com - is the alternative that gets you from account creation to working vote call in under 3 minutes.

The March 2026 App label announcement also signals what Reddit considers acceptable: one account, one developer, proxying that account's own actions. This tutorial is written entirely within that frame. Every code example operates from a single Reddit account owned by the developer running the script.

---

thing_id Format: t3_ for Posts, t1_ for Comments

Every POST /api/reddit/vote call requires a thing_id parameter. Reddit uses "fullnames" to identify content: a type prefix plus the base-36 ID of the resource.

The two fullname types relevant to voting:

• t3_ - a link post (what most people call a "post" or "submission"). Example: t3_abc123
• t1_ - a comment. Example: t1_xyz789

Getting the prefix wrong - or passing the bare numeric ID without the prefix - is the most common cause of 400 and 404 errors on the vote endpoint. The endpoint does not accept bare IDs.

Where to get a thing_id for a post you just created:

If your script submits a post and then wants to immediately vote on it, call GET /api/reddit/post/:id with the post's short ID. The response includes the fullname in the name field, which is the t3_ prefixed string you pass to the vote endpoint.

import os
import requests

API_KEY = os.environ["REDDITAPI_KEY"]
BASE = "https://api.redditapis.com"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def get_post_thing_id(post_short_id: str) -> str:
    """Get the t3_ fullname for a post by its short ID."""
    r = requests.get(
        f"{BASE}/api/reddit/post/{post_short_id}",
        headers=HEADERS,
    )
    r.raise_for_status()
    data = r.json()
    # The 'name' field contains the t3_ fullname
    return data["data"]["name"]  # e.g. "t3_abc123"

# Example: post just created with ID "1s3f3ag"
thing_id = get_post_thing_id("1s3f3ag")
print(thing_id)  # t3_1s3f3ag

For a comment's thing_id, use the name field from the comment's JSON response. Comments always return t1_ prefixed fullnames.

Full parameter reference: docs.redditapis.com/docs/write/vote

---

Step 1: Authenticate via POST /api/reddit/login

Before you can cast a vote, you need session cookies. Reddit's write endpoints require three auth tokens that prove your script is acting on behalf of a real, logged-in Reddit account. POST /api/reddit/login returns all three.

The four auth concepts:

The four credentials in the flow:

• Bearer token - your redditapis.com API key, generated at /signup. Goes in the Authorization: Bearer header on every call to api.redditapis.com.
• reddit_session - Reddit session cookie returned by POST /api/reddit/login. Identifies the Reddit account to vote as.
• loid - Long-lived account identifier cookie returned by POST /api/reddit/login. Required for all Reddit write operations.
• csrf_token - Anti-CSRF protection token returned by POST /api/reddit/login. Required for vote calls; NOT required for comment calls.

Body format note: The POST /api/reddit/login body is Content-Type: application/json. Pass username and password as flat, top-level JSON fields. This is a common mistake for developers used to Reddit's native /api/login endpoint, which is form-encoded. The redditapis.com login endpoint is JSON only.

import os
import requests

API_KEY = os.environ["REDDITAPI_KEY"]
BASE = "https://api.redditapis.com"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def get_reddit_session(username: str, password: str) -> dict:
    """
    Authenticate a Reddit account via POST /api/reddit/login.
    Body is JSON (NOT form-encoded). Returns session cookies.
    Cost: $0.012 per call.
    """
    r = requests.post(
        f"{BASE}/api/reddit/login",
        # JSON body - flat top-level fields, not form-encoded
        json={
            "username": username,
            "password": password,
            # Optional: "totp_secret": "YOUR_2FA_SECRET" for 2FA accounts
            # Optional: "proxy": "http://user:pass@host:port" for developers routing requests through a corporate proxy
        },
        headers=HEADERS,
    )
    r.raise_for_status()
    data = r.json()
    # Login response is nested: reddit_session, loid, csrf_token live under data["cookies"]
    cookies = data["cookies"]
    return {
        "reddit_session": cookies["reddit_session"],
        "loid": cookies["loid"],
        "csrf_token": cookies["csrf_token"],
    }

session = get_reddit_session(
    username=os.environ["REDDIT_USERNAME"],
    password=os.environ["REDDIT_PASSWORD"],
)
print("Authenticated. Session cookies retrieved.")

Credential security model: When you call POST /api/reddit/login, your Reddit username and password travel to redditapis.com's servers over HTTPS. redditapis.com authenticates to Reddit on your behalf and returns the resulting session cookies. The session cookies - not your password - are what you store and pass to subsequent write calls. Your password is not stored or logged by redditapis.com; only the session cookies are returned. Full details at docs.redditapis.com/docs/auth/login.

Account prerequisites: The Reddit account you authenticate with must meet a few conditions for vote calls to apply cleanly:

• The account must be active (not suspended or shadowbanned)
• For 2FA accounts, pass totp_secret in the login body
• Reddit applies platform-level quality signals to all write operations. Behavior consistent with normal human account usage reduces friction. This is Reddit-side behavior, not an API error.

---

Step 2: Call POST /api/reddit/vote

With session cookies in hand, the vote call is straightforward. The body is JSON with five required fields.

Body format note: POST /api/reddit/vote body is Content-Type: application/json. Pass thing_id, direction, reddit_session, loid, and csrf_token as flat, top-level JSON fields. Not query parameters. Not form-encoded. Flat JSON.

# Requires imports + API_KEY/BASE/HEADERS from Step 1 above.
def cast_vote(thing_id: str, direction: str, session: dict) -> dict:
    """
    Cast a vote via POST /api/reddit/vote.
    
    thing_id: "t3_" prefix for posts, "t1_" for comments
    direction: "up", "down", or "none" (to remove a vote)
    session: dict with reddit_session, loid, csrf_token from get_reddit_session()
    
    Body is JSON (NOT form-encoded, NOT query params).
    Cost: $0.005 per call.
    """
    r = requests.post(
        f"{BASE}/api/reddit/vote",
        # JSON body - flat top-level fields
        json={
            "thing_id": thing_id,
            "direction": direction,
            "reddit_session": session["reddit_session"],
            "loid": session["loid"],
            "csrf_token": session["csrf_token"],
        },
        headers=HEADERS,
    )
    r.raise_for_status()
    return r.json()

# Upvote a post
result = cast_vote(
    thing_id="t3_abc123",
    direction="up",
    session=session,
)
print("Vote cast:", result)

Complete two-step pipeline (login + vote):

import os
import requests

API_KEY = os.environ["REDDITAPI_KEY"]
BASE = "https://api.redditapis.com"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# Step 1: authenticate (cost: $0.012)
login_resp = requests.post(
    f"{BASE}/api/reddit/login",
    json={
        "username": os.environ["REDDIT_USERNAME"],
        "password": os.environ["REDDIT_PASSWORD"],
    },
    headers=HEADERS,
)
login_resp.raise_for_status()
# Login response is nested: cookies live under ["cookies"]
cookies = login_resp.json()["cookies"]

# Step 2: vote (cost: $0.005)
vote_resp = requests.post(
    f"{BASE}/api/reddit/vote",
    json={
        "thing_id": "t3_abc123",    # replace with your post's fullname
        "direction": "up",           # "up", "down", or "none"
        "reddit_session": cookies["reddit_session"],
        "loid": cookies["loid"],
        "csrf_token": cookies["csrf_token"],
    },
    headers=HEADERS,
)
vote_resp.raise_for_status()
print("Vote result:", vote_resp.json())

Total cost for one vote: $0.017 ($0.012 login + $0.005 vote). When you cache the session cookies and reuse them across many vote calls, the login cost amortizes - 100 votes from one login session costs $0.012 + (100 x $0.005) = $0.512.

Your first ~97 vote calls are covered by the $0.50 credit at /signup, once the $0.012 login is accounted for. No credit card required.

---

Common 401, 403, and 404 Errors on POST /api/reddit/vote (and How to Fix Them)

Most vote errors fall into three buckets. Identify the HTTP status code, then apply the fix.

r/redditdev·u/Leprekus

POST API /api/vote returns 404

I have been trying to upvote comments through my app But I keep getting a 404 error. The id value that I am passing is the fullname of the post, and value is either -1, 0, 1. var payload = {"id": id,"dir": value,};…

26

Open on Reddit

The 404 thread above is one of the most-searched discussions on vote API errors - the cause is almost always a malformed thing_id. Here is the complete error table:

Error code	Cause	Fix
401 Unauthorized	Session cookies expired or reddit_session is invalid	Re-call POST /api/reddit/login to get a fresh session. Treat cookies as valid for 24 hours max; pre-emptively re-login before long-running batches.
403 Forbidden	Wrong or missing csrf_token; OR the target subreddit restricts voting to members only; OR the Reddit account has not met karma or age thresholds for that community	Verify csrf_token from the login response is passed correctly. For subreddit-restricted voting: your script's account must be a member before voting. For karma restrictions: the account needs established history in that subreddit.
404 Not Found	Invalid thing_id prefix (passed bare ID or wrong type prefix); OR the post or comment was deleted between your fetch and your vote call	Confirm thing_id is t3_ for posts and t1_ for comments - never a bare ID. Validate the target still exists via GET /api/reddit/post/:id before voting.

Additional patterns to know:

• A 200 response does not always mean the vote applied at Reddit's layer. Reddit's anti-spam systems may silently discard a vote without returning an error. Monitor your account's actual vote state via GET /api/reddit/post/:id if you need confirmation.
• If your script generates a high volume of sequential votes in a short window, some votes may be silently dropped. Match human posting rhythm: space out calls to align with how a person would vote manually.

Try it: your first vote calls are on us - $0.50 in free credit at /signup, no card required.

---

The Direction Parameter: up, down, and the "none" Trick

The direction field controls which way the vote is cast. It accepts string values and integer aliases that match Reddit's native API format.

Direction values, meanings, and aliases:

The three accepted string values and their integer aliases:

• "up" (alias: 1, "upvote") - casts an upvote on the target post or comment
• "down" (alias: -1, "downvote") - casts a downvote on the target post or comment
• "none" (alias: 0, "clear", "unvote") - removes any existing vote, returning the post or comment to the unvoted state

Idempotency behavior:

• Calling POST /api/reddit/vote with direction=up on something you already upvoted is a no-op - the vote state does not change, and you are not charged extra.
• Calling with direction=down on something you previously voted up is a single-call direction switch - no intermediate unvote is needed.
• To remove a vote explicitly, pass direction=none. Do not try to remove a vote by re-calling the same direction.

# Upvote
cast_vote(thing_id="t3_abc123", direction="up", session=session)

# Downvote (can call directly even if previously upvoted - single-call switch)
cast_vote(thing_id="t3_abc123", direction="down", session=session)

# Remove the vote explicitly
cast_vote(thing_id="t3_abc123", direction="none", session=session)

# Integer aliases also work
cast_vote(thing_id="t3_abc123", direction="1", session=session)   # upvote
cast_vote(thing_id="t3_abc123", direction="-1", session=session)  # downvote
cast_vote(thing_id="t3_abc123", direction="0", session=session)   # remove

Full parameter reference: docs.redditapis.com/docs/write/vote

---

How to Vote on Reddit Without OAuth: redditapis.com vs the Official Path

The central question for developers in 2026: do I need Reddit OAuth to cast votes programmatically? The answer depends on which path you take.

The comparison above covers the four realistic options as of 2026-05-27:

Official Reddit OAuth requires a registered developer application, an approved vote scope from Reddit's review queue (2-4 weeks minimum, inconsistent approval rates in 2026 per r/redditdev), and an OAuth 2.0 refresh token implementation in your code. Once approved, costs start at $12,000/year for the Standard tier. Write scopes (including vote) require the paid tier.

PRAW (the Python Reddit API Wrapper) wraps Reddit's OAuth layer. Every PRAW limitation is an OAuth limitation: same app review requirement, same scope approval wait, same $12,000/year minimum for commercial use, same 10,000-call monthly cap on the free tier. PRAW is the right choice for hobby projects and academic research where commercial use is not a factor.

Apify Reddit Voting V2 is a no-code actor on Apify's platform for Reddit vote automation. It removes the OAuth requirement but adds a different abstraction layer. Apify Reddit Voting V2 pricing and availability as of 2026-05-27; verify current details at apify.com before purchase.

redditapis.com exposes POST /api/reddit/vote directly via a managed REST proxy. One bearer token from your account header is the only credential you manage. No developer app registration. No scope approval. No OAuth implementation. Setup takes under 3 minutes from /signup to first vote call. Cost is $0.005 per vote with a $0.50 free credit. Rate-limiting and session management are handled server-side.

The "without OAuth" keyword is the central differentiator. redditapis.com handles Reddit session authentication internally - you pass your Reddit credentials to POST /api/reddit/login, receive session cookies, and those cookies authenticate the vote. The OAuth layer is never exposed to your application.

For a deeper comparison including read endpoints, dataset access, and DM support: /reddit-api-alternatives.

---

What Happens After a Vote: Idempotency and Vote State

Vote calls are not like comment calls. Comments create new resources - each call produces a new comment, so accidental duplicate calls create duplicate comments. Votes modify a single state that exists on the post or comment object. Understanding vote state prevents common bugs.

The three states:

# State 1: No vote (starting state)
# direction=none is a no-op if no vote exists

# State 2: Upvoted
cast_vote("t3_abc123", "up", session)    # sets vote to UP

# Re-calling with same direction is a no-op (idempotent)
cast_vote("t3_abc123", "up", session)    # no change, no double-charge

# State 3: Switching direction (single-call, no intermediate step needed)
cast_vote("t3_abc123", "down", session)  # changes vote from UP to DOWN directly

# Removing the vote
cast_vote("t3_abc123", "none", session)  # back to no-vote state

Common bug: Developers sometimes pass direction=none thinking it retries a failed vote. It does not - it removes any existing vote. If a vote call returned 200 but you are not sure the vote applied (Reddit anti-spam may silently discard), check the post's vote state via GET /api/reddit/post/:id before deciding whether to retry.

# Requires imports + API_KEY/BASE/HEADERS from Step 1 above.
def get_post_vote_state(post_short_id: str) -> dict:
    """
    Read current vote state before voting, when defensive logic is needed.
    Returns post data including score and vote direction.
    Cost: $0.002 per call.
    """
    r = requests.get(
        f"{BASE}/api/reddit/post/{post_short_id}",
        headers=HEADERS,
    )
    r.raise_for_status()
    data = r.json()["data"]
    return {
        "score": data.get("score"),
        "upvote_ratio": data.get("upvote_ratio"),
        "name": data.get("name"),  # t3_ fullname for the vote call
    }

# Check before voting to avoid redundant calls
state = get_post_vote_state("abc123")
print(f"Current score: {state['score']}")
print(f"Fullname for vote: {state['name']}")

---

Pricing: $0.005 per Vote and How the Math Scales

The vote endpoint is $0.005 per call, confirmed across the docs index, endpoint detail page, and live /pricing page as of 2026-05-27. The login precondition is $0.012 per call. Session cookies can be cached and reused across many vote calls, so the login cost amortizes.

Endpoint pricing at a glance (as of 2026-05-27):

• Vote (POST /api/reddit/vote): $0.005 per call
• Login (POST /api/reddit/login): $0.012 per call (amortizes across many votes per session)
• Read (GET /api/reddit/post/:id): $0.002 per call (for pre-vote state checks)
• Free credit at signup: $0.50 - no credit card required, covers your first ~29 votes including login calls

Cost model for common scenarios:

# Scenario 1: 100 votes from one login session
login_cost = 0.012       # one login call
vote_cost = 100 * 0.005  # 100 votes at $0.005 each
total = login_cost + vote_cost
print(f"100 votes: ${total:.3f}")  # $0.512

# Scenario 2: 1,000 votes with one re-login mid-batch
login_cost = 0.012 * 2       # two login calls
vote_cost = 1000 * 0.005     # 1,000 votes
total = login_cost + vote_cost
print(f"1,000 votes: ${total:.3f}")  # $5.024

# Scenario 3: 10,000 votes per month with daily re-login
login_cost = 0.012 * 30      # one re-login per day
vote_cost = 10000 * 0.005    # 10,000 votes
total = login_cost + vote_cost
print(f"10,000 votes/month: ${total:.2f}")  # $50.36

For context: Apollo's developer Christian Selig was quoted $12,000 for 50 million requests by Reddit in 2023 (as widely reported at the time; Reddit has not published a standard commercial annual pricing schedule publicly since). At redditapis.com's $0.005/vote rate, 50 million votes would cost $250,000 - vote calls are priced at a higher per-call rate than read calls, which is expected given the write-scope complexity. The comparison point is that redditapis.com has no $12,000/year floor and no annual commitment: you pay for what you call.

Use /reddit-api-cost-calculator to model your specific volume.

---

Respecting Reddit Community Norms When Integrating the Vote API

Reddit's developer guidance states that votes must be cast by humans, and that API clients proxying a human's action one-for-one are recognized as legitimate. The March 2026 App label announcement reinforced this: Reddit officially distinguishes between accounts using automation in allowed ways ("apps") and spam bots.

Rate parity is the practical design principle: your script's call frequency should match the rhythm of a human-operated account on the same content. A developer who votes on their own post once after publishing, or who participates in communities at a normal human cadence, is well within what the platform recognizes as normal behavior.

The r/redditdev thread on upvoting via the API is worth reading for the community framing:

r/redditdev·u/pupkamajkina

Upvoting posts through the API?!

The official Reddit API guide says this: > Note: votes must be cast by humans. That is, API clients proxying a human's action one-for-one are OK, but bots deciding how to vote on content or amplifying a human's vote…

912

Open on Reddit

The "humans only" note in Reddit's developer docs reads in full: "Note: votes must be cast by humans. That is, API clients proxying a human's action one-for-one are OK." This tutorial is exactly that pattern: one Reddit account, one developer, with the script acting as the account's mechanical proxy for an action the developer would take manually.

What falls outside that frame:

• Running vote calls across multiple Reddit accounts you control simultaneously
• Using vote calls on content the account would not genuinely vote on
• Bulk vote patterns that exceed what a human account would generate in the same window

Reddit applies platform-level quality signals to all write operations regardless of how they were initiated. This is not an API-layer behavior - it is Reddit's own quality detection working at the platform layer.

For rate-limit context in longer pipelines: /blogs/reddit-api-rate-limits-2026

---

Production Patterns: Retry, Backoff, and Re-login on 401

Two realities of production vote pipelines: session cookies expire, and Reddit's upstream occasionally returns transient 5xx errors. Handle both with explicit logic.

Key facts about session lifecycle:

• There is no token-refresh endpoint. When a session expires, re-call POST /api/reddit/login to get fresh cookies.
• Cookie TTL is not documented by Reddit. Treat 24 hours as a safe ceiling for production scripts.
• Pre-emptively re-login before long-running batches rather than waiting for a 401.
• On transient 5xx errors, use exponential backoff with a maximum of 3 attempts.
• Log the full response body, not just the HTTP status code. Reddit's error responses contain diagnostic detail.

To check your remaining credit balance before a batch run, use GET /account/me:

# IMPORTANT: /account/me is root-level - NOT under /api/reddit/
# Use: https://api.redditapis.com/account/me  (correct)
# The path /api/reddit/ prefix does NOT apply to account endpoints
r = requests.get(
    "https://api.redditapis.com/account/me",
    headers=HEADERS,
)
data = r.json()
print(f"Credits remaining: {data['credits_remaining']}")

Production retry wrapper:

import time
from requests.exceptions import HTTPError

def vote_with_retry(
    thing_id: str,
    direction: str,
    get_session_fn,
    max_retries: int = 3,
) -> dict:
    """
    Vote with automatic re-login on 401 and exponential backoff on 5xx.
    
    get_session_fn: callable that returns a fresh session dict (re-calls login)
    """
    session = get_session_fn()
    for attempt in range(max_retries):
        try:
            r = requests.post(
                f"{BASE}/api/reddit/vote",
                json={
                    "thing_id": thing_id,
                    "direction": direction,
                    "reddit_session": session["reddit_session"],
                    "loid": session["loid"],
                    "csrf_token": session["csrf_token"],
                },
                headers=HEADERS,
                timeout=15,
            )
            if r.status_code == 401:
                # Session expired - re-login and retry once
                print(f"401 on attempt {attempt+1}, re-logging in...")
                session = get_session_fn()
                continue
            r.raise_for_status()
            return r.json()
        except HTTPError as e:
            status = e.response.status_code
            if status in (502, 503, 504) and attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s, 2s, 4s
                print(f"Transient {status}, retrying in {wait}s (attempt {attempt+1})...")
                time.sleep(wait)
                continue
            # Log the full response body for diagnostics
            print(f"Error body: {e.response.text}")
            raise
    raise RuntimeError(f"Vote failed after {max_retries} attempts")

For additional production patterns (async voting, corpus logging, cost tracking): /blogs/reddit-api-python-tutorial

---

Using Vote and Comment Together in a Content Workflow

The vote and comment endpoints are designed to work in sequence. A common pattern for content creators: publish a post, upvote it from your own account, then add a contextual comment that seeds the discussion. All three operations run from the same session cookies.

Important note on csrf_token scope: The csrf_token is required for vote calls. It is NOT required for comment calls. Pass only the cookies each endpoint actually requires - do not generalize the csrf_token requirement across all write operations.

import time

# After get_reddit_session() returns session dict...

# Step 1: Upvote your newly published post
# vote requires csrf_token
vote_resp = requests.post(
    f"{BASE}/api/reddit/vote",
    json={
        "thing_id": "t3_abc123",    # your post's fullname
        "direction": "up",
        "reddit_session": session["reddit_session"],
        "loid": session["loid"],
        "csrf_token": session["csrf_token"],  # REQUIRED for vote
    },
    headers=HEADERS,
)
vote_resp.raise_for_status()

# Wait between operations - consistent with normal human interaction cadence
time.sleep(3)  # explicit delay - do not skip this in production

# Step 2: Add a contextual comment
# comment does NOT require csrf_token
comment_resp = requests.post(
    f"{BASE}/api/reddit/comment",
    json={
        "post_url": "https://www.reddit.com/r/python/comments/abc123/your_post_title/",
        "text": "Sharing the data behind this post in the comments...",
        "reddit_session": session["reddit_session"],
        "loid": session["loid"],
        # csrf_token NOT passed here - comment does not require it
    },
    headers=HEADERS,
)
comment_resp.raise_for_status()
print("Vote + comment workflow complete.")

Reddit's algorithm weighs early votes heavily. A vote cast by your own account immediately after you publish is the same action you would take manually if you were watching the post.

For the comment endpoint parameter reference: docs.redditapis.com/docs/write/comment

---

Where Developers Use the Reddit Vote API in Production

The vote API endpoint fits into several production patterns, all operating from a single Reddit account per customer.

Content creator self-upvote pipeline: The most common use case. A creator publishes a post, their pipeline immediately casts an upvote from the same account, and optionally adds a seeding comment. The goal is to give the post early signal so Reddit's algorithm evaluates it with at least one vote in the first few minutes. This is identical to what the creator would do manually if they were watching the post go live.

Comment moderation tooling: Community moderators build tools that upvote high-quality replies and downvote spam or off-topic content. The vote call executes the action the moderator would take manually, at the cadence a human moderator could realistically achieve. Combined with GET /api/reddit/comments for reading the thread, this becomes a complete moderation assist pipeline.

Sentiment-action loops: A monitoring script reads comments via GET /api/reddit/search or GET /api/reddit/posts, scores them by keyword or sentiment, and upvotes comments that meet a quality threshold. The vote call closes the loop from detection to action in the same script run.

Engagement automation in customer-success workflows: A developer's product generates content on Reddit; a lightweight pipeline votes on that content after it goes live. After a vote succeeds, the DM endpoint extends the workflow: /blogs/how-to-send-reddit-dm-via-api.

Brand-monitoring compound loop: After a vote API integration ships, a complementary tactic is setting up F5Bot (Reddit) and Google Alerts for your product keywords. When brand mentions fire, your script can pull the thread, evaluate whether the post merits engagement, and vote and comment from your account. This compound approach is described in the developer tip below:

Hridoy Rehman

@hridoyreh

How to get customers with $0: 1. Set up F5Bot with your keywords. 2. Find discussions from Reddit. 3. Make 100% valuable comments and mention your brand name when necessary. 4. People will be curious and search for your tool on Google. That's how you can get a customer... https… Show more

The F5Bot plus Google Alerts loop is zero-budget. It compounds brand-mention signals (a factor AI Overviews use for citation weighting) while driving curious searchers directly to your product. Combining it with a vote pipeline means you can engage with brand mentions in a timely way, with your review step before any action executes.

For use case details across all 14 production workloads: /reddit-api-usecases

---

Where to Go Next

This tutorial covers the complete POST /api/reddit/vote path from auth to production retry logic. Three next steps:

• Reddit API in Python: The Complete No-PRAW Tutorial - extend your vote calls into a full Python pipeline covering posts, comments, search, and DMs
• How to Send a Reddit DM via API - add DMs to your content workflow; the auth session from login is reused across both calls
• Reddit API Rate Limits in 2026 - understand request cadence and what the platform enforces at the write-endpoint layer

Questions about your specific use case? /contact

---

Start free. $0.50 credit at signup, no card required. First vote in minutes - account creation, one login call, one vote call.

Get your API key →