Track score, upvote ratio, and comment velocity across all your posts. Double down on winners.
API Endpoints
Most Reddit marketers post and move on, with no systematic way to distinguish which variables actually drove performance. Was it the title format? The subreddit? The time of day? The body length? Without a structured analysis, every week is a fresh start — no accumulated learning, no improvement curve.
The data exists in your post history, but it's buried. Reddit's own analytics are minimal and don't expose the historical data you need for pattern analysis. The result is that even experienced Reddit marketers are essentially guessing — posting what feels right rather than what the data shows works.
A proper A/B analysis of Reddit post variables can identify title formats, subreddits, and timing combinations that 2–4× your average score. This compounding improvement is the difference between Reddit being a minor traffic source and being a significant, predictable acquisition channel.
The /ai-posts endpoint returns score, upvote_ratio, comment_count, and visits_count for every post in your history — synced automatically as Reddit updates the data. With a full post history, you can segment by every variable that matters: title format, subreddit category, post type, day of week, body length, link vs text. The patterns are almost always there once you look — and the patterns compound when you act on them.
Export your full post history
Call GET /ai-posts?status=posted&per_page=100 and paginate through all pages to get your complete history. If you've been posting for months, you may have 200–500 posts across dozens of subreddits — enough for statistically meaningful analysis. Write the full dataset to a database or CSV.
Parse title patterns with regex
Classify each post's title by format: question (ends with ?), number-led (starts with digit or contains "X%"), how-to (starts with "How"), story (contains "we" or "I"), announcement (contains "Show", "Launch"). Calculate average score and upvote_ratio per format. This usually reveals one or two patterns with 2–3× better performance.
Segment performance by subreddit
Group posts by subreddit_name and calculate avg_score, avg_upvote_ratio, and post_count per community. Sort by avg_score. This tells you your best-performing communities — often not the ones you intuitively think are best. Communities with consistent high scores are worth posting to more frequently; low performers should be deprioritised.
Analyse by day and hour
Extract the posted_at timestamp for each post and calculate day_of_week and hour_of_day. Cross-reference with score. Most products have a 2–3× score difference between their best and worst posting time. This is usually worth more optimisation effort than any other single variable.
Control for subreddit size
A score of 50 in a 1,000-member community is proportionally far more impressive than 50 in a 100,000-member community. Normalise scores by dividing by member_count to get a "score per 1000 members" metric. This reveals which small communities have disproportionately engaged audiences for your content.
Build a top-performer template library
Extract the top 10% of posts by normalised score. For each, record: title format and length, first sentence structure, body length, whether it included a link or image, subreddit, posting time. These are your empirical templates. Pass them as few-shot examples to your content generator.
Implement a continuous improvement loop
After each weekly batch, run the analysis again on the new data and update your template library. Track your rolling 30-day average score — if it's trending up, the system is working. A 10% improvement per month compounds to 2× performance improvement over 7 months without any additional effort.
Full performance analysis
interface Post {
id: string; title: string; subreddit_name: string;
score: number; upvote_ratio: number; comment_count: number;
posted_at: string; post_type: string; body: string;
}
async function analysePerformance() {
const res = await fetch( 0 , { headers: HEADERS });
const posts = (await res.json()).data as Post[];
1
const bySubreddit = posts.reduce((acc, p) => {
const k = p.subreddit_name;
if (!acc[k]) acc[k] = [];
acc[k].push(p);
return acc;
}, {} as Record<string, Post[]>);
const subStats = Object.entries(bySubreddit).map(([name, ps]) => ({
subreddit: name,
posts: ps.length,
avgScore: ps.reduce((s, p) => s + p.score, 0) / ps.length,
avgRatio: ps.reduce((s, p) => s + p.upvote_ratio, 0) / ps.length,
topPost: ps.sort((a, b) => b.score - a.score)[0].title,
}));
subStats.sort((a, b) => b.avgScore - a.avgScore);
console.table(subStats.slice(0, 10));
return subStats;
}Identify winning title patterns
import requests, re
from collections import defaultdict
def analyse_titles(api_key: str):
headers = { 0 : f 1 }
posts = requests.get(
2 ,
params={ 3 : 4 , 5 : 100},
headers=headers,
).json()[ 6 ]
patterns = {
7 : r 8 ,
9 : r 10 ,
11 : r 12 ,
13 : r 14 ,
}
results = defaultdict(list)
for p in posts:
for name, regex in patterns.items():
if re.search(regex, p[ 15 ], re.I):
results[name].append(p[ 16 ])
for pattern, scores in results.items():
print(f 17 )Drawing conclusions from too few posts
A pattern based on 5 posts is noise. Wait until you have at least 30 posts per segment before treating a performance difference as meaningful. Early conclusions lead to premature optimisation that locks you into a strategy that's coincidentally good but not actually signal.
Ignoring upvote_ratio in favour of raw score
A post with score 100 and upvote_ratio 0.60 is controversial — half the audience disliked it. A post with score 40 and upvote_ratio 0.94 is high-quality signal. Sort by ratio first, then score, to identify your best content templates.
Treating all subreddits as comparable
Comparing a score of 15 in r/smallbusiness (1k members) against r/entrepreneur (1M members) without normalising by size produces meaningless comparisons. Always normalise scores by community size before comparing across subreddits.
40–80%
Score improvement over 90 days
Average improvement in rolling avg score for teams that run systematic A/B analysis and apply learnings.
2–3×
Best vs worst posting time
Typical score multiplier between optimal and suboptimal posting times for a given subreddit.
top 10%
Top performer identification
The top 10% of posts by normalised score contain the patterns worth systematically replicating.
How long does it take to have enough data for meaningful analysis?
You need at least 30 posts per segment to draw reliable conclusions. At 5 posts/week across 3 subreddits, you'll have enough data for a basic title format analysis after about 6 weeks. Broader multi-variable analysis needs 3–4 months of consistent posting.
Does Reoogle track visits (not just Reddit upvotes)?
Yes — the visits_count field on each post tracks clicks on your tracked link URL. This is separate from Reddit's upvote score and tells you how many people actually clicked through to your site. High visits with low score means your title drove clicks but not engagement; high score with low visits means strong community engagement but weak CTA.
What's the most impactful variable to optimise first?
In order of typical impact: (1) subreddit selection — posting to the wrong community is a complete waste; (2) posting time — 2–3× score difference between best and worst time; (3) title format — usually 1.5–2× difference; (4) body length — diminishing returns after ~300 words for most communities.
Can I export the data for analysis in Excel or Python?
The API returns standard JSON that's trivially convertible to CSV or DataFrame. Call GET /ai-posts with per_page=100 and paginate to export all posts. In Python, use pd.DataFrame(posts) and you have a fully queryable dataset in seconds.
Business value
Teams that systematically analyse Reddit post performance and apply learnings see 40–80% improvement in average score over 90 days. Higher scores mean more organic reach — compounding returns without additional ad spend.
Generate an API key from your developer dashboard and make your first request in minutes.