DEV Community

Alex Spinov
Alex Spinov

Posted on

I Scraped My Own Dev.to Analytics — Here Is What 500 Articles Taught Me

#devto #discuss #beginners #productivity

I have published over 500 articles on Dev.to in the past two weeks. Yes, that sounds insane. Here is what the data actually shows.

The Experiment

I wanted to understand what makes technical content perform. So I treated my own Dev.to account as a dataset.

Using the Dev.to API, I pulled analytics for all 500+ articles and analyzed the patterns.

import requests
import json

headers = {"api-key": "YOUR_DEVTO_API_KEY"}
all_articles = []

for page in range(1, 7):
    response = requests.get(
        f"https://dev.to/api/articles/me?per_page=100&page={page}",
        headers=headers
    )
    all_articles.extend(response.json())

print(f"Total articles: {len(all_articles)}")
total_views = sum(a["page_views_count"] for a in all_articles)
print(f"Total views: {total_views}")
Enter fullscreen mode Exit fullscreen mode

Result: 508 articles, 3,815 total views.

Finding #1: Only 20% of Articles Get Any Views

Out of 508 articles, only ~100 have views above zero. The other 400+ sit at exactly 0.

Articles with 0 views: 408 (80%)
Articles with 1-10 views: 68 (13%)
Articles with 10-50 views: 30 (6%)
Articles with 50+ views: 2 (0.4%)
Enter fullscreen mode Exit fullscreen mode

Takeaway: Quantity does not equal quality. Publishing 500 articles is meaningless if 400 of them get zero traction.

Finding #2: Listicles Dramatically Outperform Tutorials

My top 10 articles by views all follow the same pattern:

"N [Adjective] [Things] That [Benefit]"
Enter fullscreen mode Exit fullscreen mode

Examples that worked:

  • "5 Free APIs That..." — 40+ views
  • "7 Python Libraries That..." — 30+ views
  • "10 GitHub Repos You Should..." — 25+ views

Examples that flopped:

  • "Understanding Async Python" — 0 views
  • "How OAuth2 Works" — 0 views
  • "My Experience with Docker Compose" — 0 views

The pattern is clear: Numbers in titles + promise of value = views. Generic educational content = invisible.

Finding #3: Tags Matter More Than Content

The tags ai, beginners, discuss, and python correlate with higher views.

The tags tutorial, devops, node, and react correlate with lower views.

This makes sense — beginners has the largest audience, and discuss encourages engagement.

Finding #4: External Traffic > Dev.to Feed

My highest-traffic content was NOT discovered through the Dev.to feed. It came from:

  1. Hacker News — one article hit the front page and drove 100+ views
  2. Google/Kagi search — SEO-optimized articles get steady trickle
  3. GitHub cross-links — linking from popular repos drives traffic

Takeaway: Dev.to is not a discovery platform. It is a hosting platform. Distribution must come from elsewhere.

Finding #5: The First Comment Is Everything

Out of 508 articles, I received exactly 1 comment. ONE. On article number 487.

The article that got a comment? It asked a genuine question at the end and used the discuss tag.

Zero comments on the other 507 articles means zero algorithm boost, zero social proof, zero engagement loop.

What I Would Do Differently

If I started over:

  1. Write 2 articles per week, not 50 — quality over quantity
  2. Always use number-based titles — "7 Things" beats "How To"
  3. Always end with a question — drives comments
  4. Cross-post to HN, Reddit, Twitter — Dev.to alone is not enough
  5. Use discuss + beginners tags — largest audience
  6. Tell stories, not just tutorials — "I did X and Y happened" beats "How to do X"

The Code to Analyze Your Own Articles

Want to do this with your own Dev.to account? Here is the complete script:

import requests
from collections import Counter

API_KEY = "your_api_key_here"  # Get from dev.to/settings/extensions
headers = {"api-key": API_KEY}

# Fetch all articles
articles = []
for page in range(1, 20):
    resp = requests.get(
        f"https://dev.to/api/articles/me?per_page=100&page={page}",
        headers=headers
    )
    batch = resp.json()
    if not batch:
        break
    articles.extend(batch)

# Analysis
total_views = sum(a["page_views_count"] for a in articles)
total_reactions = sum(a["positive_reactions_count"] for a in articles)
with_views = [a for a in articles if a["page_views_count"] > 0]

print(f"Total articles: {len(articles)}")
print(f"Total views: {total_views}")
print(f"Total reactions: {total_reactions}")
print(f"Articles with views: {len(with_views)} ({len(with_views)*100//len(articles)}%)")
print(f"Avg views per article: {total_views/len(articles):.1f}")

# Top performers
print("\n--- TOP 10 BY VIEWS ---")
for a in sorted(articles, key=lambda x: x["page_views_count"], reverse=True)[:10]:
    print(f"{a[page_views_count]:>4}v {a[positive_reactions_count]:>2}r | {a[title][:60]}")

# Tag analysis
all_tags = []
for a in articles:
    all_tags.extend(a["tag_list"])
tag_counts = Counter(all_tags).most_common(10)
print("\n--- MOST USED TAGS ---")
for tag, count in tag_counts:
    tagged = [a for a in articles if tag in a["tag_list"]]
    avg = sum(a["page_views_count"] for a in tagged) / len(tagged)
    print(f"{tag:>15}: {count} articles, avg {avg:.1f} views")
Enter fullscreen mode Exit fullscreen mode

What surprised you most about these findings?

I genuinely want to know — if you ran this on your own articles, what patterns would you find? Have you noticed similar trends?

Drop your insights in the comments. If you share your top-performing title format, I will analyze why it works.

This is part of my experiment in data-driven content creation. I write about web scraping, APIs, and developer analytics.

Tools I used: Dev.to API, Python, and my web scraping toolkit.

Top comments (0)