The Reddit Ads API: What You Can and Can't Automate

The Reddit Ads API lets approved advertisers and partners automate the mechanical side of Reddit advertising: pulling performance reports, reading campaign structures, changing statuses, adjusting bids and budgets, and creating campaigns and ad groups in code. It does not automate the gated parts: getting API access, passing Reddit's ad policy review, approving creative, or provisioning accounts. Below is what the reddit ads api can and cannot do as of October 2026, and how to build automations that stay safe in production when documentation is incomplete and reporting data lags.

What the Reddit Ads API is (and what it is not)

The Reddit Ads API is the advertising interface for Reddit, the American social news aggregation website and discussion portal, and it handles campaign management, targeting and ad analytics rather than posts and comments. Teams confuse it with two other Reddit interfaces, and that confusion causes most failed projects.

Where the documentation lives

Reddit hosts the Ads API documentation on its business site at business.reddit.com. It covers creating and managing campaigns, targeting options, reporting and analytics, and how to access the API to monitor performance. The general Reddit API documentation at reddit.com/dev/api is a different document set for platform data. If you only need Reddit Ads data in a warehouse or BI tool, Adverity's Reddit Ads guide documents prerequisites, data fields, breakdowns, timezone handling and limits on historical data availability, which is useful even if you build your own pipeline.

Why the Data API distinction matters now

Reddit is changing its API policy. According to Wikipedia's account of the Reddit API controversy, Reddit announced in September 2026 that it would close its public API in November 2026 and shut down its RSS feeds. That announcement concerns the public data interface, not ad management, but any workflow that blends ad data with thread data scraped through the public API needs a plan. Confirm your Ads API status with your Reddit account team before you commit engineering time.

Getting access and authenticating

Reddit Ads API access requires an approved ads account, a registered app and an OAuth2 token with ads scopes, and none of these can be granted by your own code. Plan for a manual setup phase before any automation runs.

1. Confirm the ads account exists, has billing set up and has the business admin who will own the integration.
2. Request Ads API access through Reddit's business channels or your account representative. Expect a review before you get a key.
3. Register an app on a Reddit account tied to the business (not an engineer's personal account) to get a client ID and secret.
4. Run the OAuth2 authorization code flow once with permanent duration, requesting ads scopes such as read and edit permissions. Request read-only scopes for reporting-only jobs.
5. Store the refresh token in a secrets manager and exchange it for short-lived access tokens at runtime.

import requests, os

def get_access_token():
    resp = requests.post(
        "https://www.reddit.com/api/v1/access_token",
        auth=(os.environ["REDDIT_CLIENT_ID"], os.environ["REDDIT_CLIENT_SECRET"]),
        data={"grant_type": "refresh_token",
              "refresh_token": os.environ["REDDIT_REFRESH_TOKEN"]},
        headers={"User-Agent": "acme-ads-sync/1.0 by acme-ads-admin"},
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()["access_token"]  # cache until shortly before expires_in

Security basics for the integration:

• Keep client secrets and refresh tokens in AWS Secrets Manager, Google Secret Manager or HashiCorp Vault, never in code or CI logs.
• Use separate apps and tokens for read-only reporting and for write jobs, so a leaked reporting token cannot change spend.
• Send a descriptive User-Agent; Reddit's API rules expect one and it helps Reddit support trace your traffic.
• Rotate secrets on staff changes and when the owning admin leaves the company.

What you can and can't automate

You can fully automate reads, reporting and bounded edits to existing campaigns. Anything that creates new ads or touches audiences can be partly automated. Access, policy review and creative approval cannot be automated at all. The matrix below assumes an approved account with read and edit scopes.

Fully automatable

• Daily and intraday report pulls into BigQuery, Snowflake or Redshift.
• Pausing campaigns that exceed a cost-per-result ceiling after enough spend.
• Shifting budget between ad groups within preset limits.
• Nightly snapshots of the full account structure for change tracking.

Partially automatable

Creating campaigns from a template works, but a new ad does not serve until Reddit approves it, so your job must create the object, then poll its review status and alert a human on rejection. Targeting changes are technically simple, but adding or removing subreddits shifts brand context, which is why most enterprise teams put an approval gate in front of them. Ad formats that place a brand inside threads, such as Reddit conversation ads, raise the stakes on that review because the copy sits next to community discussion.

Manual by design

Access approval, business verification, billing, policy review and creative sign-off are decisions that people make, and no API call can make them for you. Teams launching their first enterprise Reddit campaign should run it by hand before writing any automation, so the rules encode decisions people have already tested.

Endpoints mapped to workflows

The Ads API is organized around ad accounts, campaigns, ad groups, ads and reports, and each resource supports a specific operational workflow. Current versions follow a REST pattern under ads-api.reddit.com with versioned paths. Confirm exact path names and fields in the current documentation, because Reddit has revised them between versions.

Here is a bounded PATCH. The rule engine supplies the new value, and the client checks it against caps before sending:

PATCH /api/v3/ad_groups/{ad_group_id}
Authorization: Bearer <token>
Content-Type: application/json

{"data": {"configured_status": "PAUSED"}}

What to store and how often to poll

• Store IDs, names, status, budget, bid, targeting and last-modified time for every campaign, ad group and ad.
• Snapshot structure nightly and before every write, so you can diff and roll back.
• Pull reports hourly for pacing alerts, and daily for a full re-pull of the trailing 7 days to capture late conversions.
• Poll review status for new ads every 15 to 30 minutes until a final state, then stop.

Reddit Conversions API

The Reddit Conversions API is a server-to-server integration that sends conversion and web event data from your servers to Reddit. It is used alongside the Reddit Pixel when browser data is incomplete because of cookies, ad blockers or privacy restrictions. It automates a different layer from the Ads API:

• Tracking purchases, sign-ups, lead submissions and other key events.
• Mapping catalog or product and event data to signal sources.
• Matching and deduplicating users with hashed identifiers such as email or phone number.
• Updating audiences in real time for retargeting.
• Passing consent and limited data use (LDU) settings.

Hash identifiers with SHA-256 after normalizing them (lowercase, trimmed email; E.164 phone), and send the same event ID from Pixel and CAPI so Reddit can deduplicate. Verify events in Reddit's Events Manager before you let any bidding rule depend on them.

Designing around limits, errors and reporting lag

Production Reddit Ads automations fail on undocumented limits and moving data more often than on syntax. Design every job to retry safely, to read data that is still settling, and to confirm its own writes.

Error classes and what to do

import time, random

def call_with_backoff(fn, max_tries=6):
    for attempt in range(max_tries):
        r = fn()
        if r.status_code not in (429, 500, 502, 503, 504):
            return r
        wait = float(r.headers.get("Retry-After", 2 ** attempt))
        time.sleep(wait + random.uniform(0, 1))
    raise RuntimeError("Retries exhausted")

Designing when the documentation is incomplete

• Rate limits: treat them as unknown. Read rate-limit headers when present, cap concurrency at a few requests at a time, and spread scheduled jobs so they don't all fire on the hour.
• Idempotency: write absolute values ("set budget to 500"), never relative ones ("add 10%"), so a retried request cannot double a change.
• Create calls: before retrying a POST, search for an object with your deterministic name or external ID, so a timeout does not produce duplicate campaigns.
• Pagination: follow cursors until none remain and compare counts against the previous snapshot. A sudden drop usually means a truncated read, not deleted campaigns.
• Verify persistence: after every PATCH, GET the object and compare fields. Log a mismatch as a failed change even if the write returned 200.

Reporting design: freshness, attribution and timezones

Ad reporting is eventually consistent. Spend and impressions for today keep moving, and conversions arrive late because they are credited to the click or view date inside the attribution window. Three rules keep reports honest:

• Re-pull the trailing 7 days every night and overwrite, rather than appending one new day.
• Request reports in the ad account's timezone and store it with every row. Mixing UTC with account time shifts spend across days.
• Compute CTR, CPC and CPM yourself from raw clicks, impressions and spend (CTR = clicks / impressions; CPC = spend / clicks; CPM = spend / impressions × 1,000) so definitions match your other platforms.

Safe automation rules

Rules fail when they act on thin data. For example, a pacing rule might work like this:

1. Only evaluate ad groups with at least $200 spend and 100 clicks in the lookback window.
2. Exclude the most recent 48 hours from cost-per-conversion calculations, because conversions are still arriving.
3. Change a budget by no more than 20% per adjustment and no more than once per 72 hours (the cooldown).
4. Cap total automated budget increases per account at a fixed daily dollar amount.
5. Route any change above the cap to a human for approval instead of applying it.

Those figures are illustrative; set your own from historical variance. Benchmarks need the same care. Compare Reddit CPCs with your Reddit history and objective, not with search, where intent differs.

Where Tellr fits alongside API automation

Tellr covers the part of Reddit performance that an API script cannot: what the brand says, where it says it, and whether it is approved. API automation handles bids, budgets and reports. Tellr runs a governed program that decides what goes into the threads and ad feeds buyers read, which matters most for teams weighing Reddit ads for B2B audiences.

• Subreddit mapping that tells you which communities to target and which to avoid.
• A daily thread radar and guideline-checked replies behind an approval gate.
• Category ad intelligence and ready-to-run creative for paid campaigns.
• Weekly tracking of who Google and AI Overviews cite for your category.
• One senior team, with approvals and an audit trail across every product.

Tellr is a managed program built for teams spending $10k+ a month at companies with 200+ employees, so a small team that only needs a reporting script is better served by a connector or in-house code.

Architecture, testing and a shipping checklist

A production Reddit Ads automation needs more than a script. It has seven parts: a scheduler, a token store, an API client, a rules engine, a datastore, notifications and an audit log. Each part has one job.

Persist a structure snapshot before each write and a change-log row after it, keyed by object ID and run ID. Rollback then becomes a query: select the pre-change values for a run and PATCH them back.

Testing without a true sandbox

Do not assume a full sandbox exists for your account. Ask Reddit, and plan as if you will test against live spend. That makes these steps mandatory:

1. Dry-run mode: run the rules engine for one to two weeks, logging proposed changes without sending them, and have a media buyer review them.
2. Historical replay: feed 60 to 90 days of stored reports through the rules and check whether they would have paused winners or overspent.
3. Low-budget staging: enable writes on one or two test campaigns with small daily budgets before touching core spend.
4. Gradual rollout: expand by account or campaign group, keeping the daily change caps tight for the first month.
5. Kill switch: keep one config flag that stops all writes immediately while leaving reporting running.

Shipping checklist

• Ads API access approved and owned by a business service account.
• Separate read-only and write tokens, stored in a secrets manager.
• Backoff on 429 and 5xx; no retries on 400, 403 or 422.
• Absolute-value writes, duplicate checks before POST retries, full pagination.
• Every write verified with a follow-up GET and logged with before and after values.
• Trailing 7-day report re-pulls in the account timezone.
• Rules with spend and click minimums, cooldowns and daily caps.
• Independent spend anomaly alerts and a tested rollback.
• Human approval for new ads, targeting changes and anything above the caps.

The reddit ads api rewards teams that automate the repeatable work, such as reporting, pacing and pausing, and keep people in charge of access, policy and creative. Build the guardrails first, prove the rules on historical data, and only then let the code move real budget.

FAQ