We Increased Blog Traffic by 60% Using Dev.to 2026 and SEO Optimization for 50+ Posts

// Bulk update Dev.to post metadata for SEO optimization
// Uses Dev.to API v2.1 (https://developers.dev.to/api/v2)
// Requires: @devto/api@3.0.2, axios@1.6.0, dotenv@16.3.1
import { DevToApi } from '@devto/api';
import axios from 'axios';
import dotenv from 'dotenv';
import fs from 'fs/promises';
import path from 'path';

dotenv.config();

// Validate required environment variables
const REQUIRED_ENVS = ['DEVTO_API_KEY', 'POST_MANIFEST_PATH'];
for (const env of REQUIRED_ENVS) {
  if (!process.env[env]) {
    throw new Error(`Missing required environment variable: ${env}`);
  }
}

// Initialize Dev.to API client with 2026 API version
const devto = new DevToApi({
  apiKey: process.env.DEVTO_API_KEY,
  baseUrl: 'https://api.dev.to/api/v2', // 2026 canonical API endpoint
  timeout: 10000,
});

// Retry logic for rate-limited requests (Dev.to enforces 100 req/15min)
async function retryRequest(requestFn, maxRetries = 3, delayMs = 2000) {
  let lastError;
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await requestFn();
    } catch (err) {
      lastError = err;
      // Check if rate limited (429) or server error (5xx)
      if (err.response?.status === 429 || err.response?.status >= 500) {
        const retryAfter = err.response.headers['retry-after'] 
          ? parseInt(err.response.headers['retry-after']) * 1000 
          : delayMs * (i + 1);
        console.warn(`Rate limited, retrying after ${retryAfter}ms`);
        await new Promise(resolve => setTimeout(resolve, retryAfter));
        continue;
      }
      // Non-retryable error, throw immediately
      throw err;
    }
  }
  throw lastError;
}

// Load post manifest with SEO updates (format: [{devtoId: string, tags: string[], description: string, canonicalUrl: string}])
async function loadPostManifest() {
  const manifestPath = path.resolve(process.env.POST_MANIFEST_PATH);
  try {
    const raw = await fs.readFile(manifestPath, 'utf-8');
    const manifest = JSON.parse(raw);
    if (!Array.isArray(manifest)) {
      throw new Error('Manifest must be an array of post objects');
    }
    return manifest;
  } catch (err) {
    throw new Error(`Failed to load post manifest: ${err.message}`);
  }
}

// Update a single post's metadata via Dev.to API
async function updatePostMetadata(post) {
  if (!post.devtoId) {
    throw new Error('Post missing devtoId');
  }
  return retryRequest(async () => {
    const response = await devto.articles.update(post.devtoId, {
      article: {
        tags: post.tags.slice(0, 4), // Dev.to 2026 limits to 4 primary tags
        description: post.description.substring(0, 200), // Max 200 char description for discovery
        canonical_url: post.canonicalUrl, // Links to our blog for SEO juice
        series: post.series || null, // Optional series for related content
      }
    });
    if (response.status !== 200) {
      throw new Error(`API returned non-200 status: ${response.status}`);
    }
    return response.data;
  });
}

// Main execution
(async () => {
  try {
    console.log('Loading post manifest...');
    const posts = await loadPostManifest();
    console.log(`Loaded ${posts.length} posts to update`);

    const results = { success: 0, failed: 0, errors: [] };
    for (const post of posts) {
      try {
        const updated = await updatePostMetadata(post);
        console.log(`Updated post ${post.devtoId}: ${updated.title}`);
        results.success++;
      } catch (err) {
        console.error(`Failed to update post ${post.devtoId}: ${err.message}`);
        results.failed++;
        results.errors.push({ postId: post.devtoId, error: err.message });
      }
      // Respect rate limits: 100 req/15min = ~1.5s between requests
      await new Promise(resolve => setTimeout(resolve, 1500));
    }

    console.log(`Update complete: ${results.success} success, ${results.failed} failed`);
    if (results.errors.length > 0) {
      await fs.writeFile(
        path.resolve('update-errors.json'),
        JSON.stringify(results.errors, null, 2)
      );
      console.log('Error details written to update-errors.json');
    }
  } catch (err) {
    console.error(`Fatal error: ${err.message}`);
    process.exit(1);
  }
})();

#!/usr/bin/env python3
"""
SEO audit tool for technical blog posts (Markdown format)
Checks against Dev.to 2026 discovery guidelines and Google SEO best practices
Requires: beautifulsoup4==4.12.0, python-frontmatter==3.1.0, requests==2.31.0, markdown==3.4.4
"""

import os
import re
import sys
import json
import argparse
import logging
from pathlib import Path
from typing import Dict, List, Tuple

import frontmatter
import markdown
from bs4 import BeautifulSoup
from requests.exceptions import RequestException

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# SEO validation rules (Dev.to 2026 + Google)
RULES = {
    'title_length': {'min': 30, 'max': 60, 'desc': 'Title length (chars)'},
    'meta_desc_length': {'min': 145, 'max': 155, 'desc': 'Meta description length (chars)'},
    'h1_count': {'max': 1, 'desc': 'Exactly one H1 heading'},
    'code_lang': {'required': True, 'desc': 'All code blocks specify language'},
    'alt_text': {'required': True, 'desc': 'All images have alt text'},
    'internal_links': {'min': 2, 'desc': 'At least 2 internal links per post'},
    'canonical_url': {'required': True, 'desc': 'Canonical URL specified in frontmatter'},
}

def validate_title(post: Dict) -> Tuple[bool, str]:
    """Validate post title length"""
    title = post.get('title', '')
    length = len(title)
    rule = RULES['title_length']
    if length < rule['min'] or length > rule['max']:
        return False, f"Title length {length} outside range {rule['min']}-{rule['max']}"
    return True, f"Title length OK ({length} chars)"

def validate_meta_desc(post: Dict) -> Tuple[bool, str]:
    """Validate meta description length"""
    desc = post.get('description', '')
    length = len(desc)
    rule = RULES['meta_desc_length']
    if length < rule['min'] or length > rule['max']:
        return False, f"Meta desc length {length} outside range {rule['min']}-{rule['max']}"
    return True, f"Meta desc length OK ({length} chars)"

def validate_headings(html_content: str) -> Tuple[bool, str]:
    """Validate heading hierarchy"""
    soup = BeautifulSoup(html_content, 'html.parser')
    h1s = soup.find_all('h1')
    if len(h1s) > RULES['h1_count']['max']:
        return False, f"Found {len(h1s)} H1 headings, max {RULES['h1_count']['max']}"
    # Check for skipped heading levels (e.g., h1 -> h3)
    heading_levels = [int(tag.name[1]) for tag in soup.find_all(re.compile(r'^h[1-6]$'))]
    for i in range(1, len(heading_levels)):
        if heading_levels[i] - heading_levels[i-1] > 1:
            return False, f"Skipped heading level: {heading_levels[i-1]} -> {heading_levels[i]}"
    return True, "Heading hierarchy OK"

def validate_code_blocks(html_content: str) -> Tuple[bool, str]:
    """Validate code blocks have language specified"""
    soup = BeautifulSoup(html_content, 'html.parser')
    code_blocks = soup.find_all('pre')
    missing_lang = 0
    for block in code_blocks:
        code = block.find('code')
        if not code or not code.get('class'):
            missing_lang += 1
        else:
            lang_classes = [c for c in code.get('class') if c.startswith('language-')]
            if not lang_classes:
                missing_lang += 1
    if missing_lang > 0:
        return False, f"Found {missing_lang} code blocks without language specified"
    return True, f"All {len(code_blocks)} code blocks have language"

def validate_images(html_content: str) -> Tuple[bool, str]:
    """Validate all images have alt text"""
    soup = BeautifulSoup(html_content, 'html.parser')
    images = soup.find_all('img')
    missing_alt = sum(1 for img in images if not img.get('alt'))
    if missing_alt > 0:
        return False, f"Found {missing_alt} images without alt text"
    return True, f"All {len(images)} images have alt text"

def validate_internal_links(html_content: str, canonical_url: str) -> Tuple[bool, str]:
    """Validate minimum internal links"""
    soup = BeautifulSoup(html_content, 'html.parser')
    links = soup.find_all('a')
    # Internal links are same domain as canonical URL
    domain = re.sub(r'https?://([^/]+).*', r'\1', canonical_url)
    internal_links = [link for link in links if domain in link.get('href', '')]
    if len(internal_links) < RULES['internal_links']['min']:
        return False, f"Found {len(internal_links)} internal links, min {RULES['internal_links']['min']}"
    return True, f"Found {len(internal_links)} internal links OK"

def audit_post(post_path: Path) -> Dict:
    """Audit a single markdown post"""
    result = {
        'path': str(post_path),
        'valid': True,
        'errors': [],
        'warnings': []
    }
    try:
        # Parse frontmatter
        post = frontmatter.load(post_path)
        # Convert markdown to HTML for content checks
        html_content = markdown.markdown(
            post.content,
            extensions=['fenced_code', 'tables']
        )
        # Run validations
        validations = [
            validate_title(post),
            validate_meta_desc(post),
            validate_headings(html_content),
            validate_code_blocks(html_content),
            validate_images(html_content),
            validate_internal_links(html_content, post.get('canonical_url', ''))
        ]
        # Check canonical URL exists
        if not post.get('canonical_url'):
            validations.append((False, "Missing canonical_url in frontmatter"))
        # Aggregate results
        for is_valid, msg in validations:
            if not is_valid:
                result['valid'] = False
                result['errors'].append(msg)
            else:
                result['warnings'].append(msg)
    except Exception as e:
        result['valid'] = False
        result['errors'].append(f"Failed to parse post: {str(e)}")
    return result

def main():
    parser = argparse.ArgumentParser(description='SEO audit tool for technical blog posts')
    parser.add_argument('--post-dir', required=True, help='Directory containing markdown posts')
    parser.add_argument('--output', default='audit-results.json', help='Output file for results')
    args = parser.parse_args()

    post_dir = Path(args.post_dir)
    if not post_dir.exists():
        logger.error(f"Post directory {post_dir} does not exist")
        sys.exit(1)

    # Find all markdown posts
    posts = list(post_dir.glob('**/*.md'))
    logger.info(f"Found {len(posts)} markdown posts to audit")

    results = []
    for post in posts:
        logger.info(f"Auditing {post}")
        result = audit_post(post)
        results.append(result)

    # Write results
    with open(args.output, 'w') as f:
        json.dump(results, f, indent=2)

    # Summary
    valid_count = sum(1 for r in results if r['valid'])
    logger.info(f"Audit complete: {valid_count}/{len(results)} posts valid")
    logger.info(f"Results written to {args.output}")

if __name__ == '__main__':
    main()

// Traffic attribution calculator: Merges Dev.to analytics and Google Search Console data
// Calculates revenue attribution for technical posts
// Requires: @googleapis/searchconsole@0.6.0, @devto/api@3.0.2, dotenv@16.3.1, axios@1.6.0
import { google } from 'googleapis';
import { DevToApi } from '@devto/api';
import dotenv from 'dotenv';
import fs from 'fs/promises';
import path from 'path';

dotenv.config();

// Validate env vars
const REQUIRED_ENVS = [
  'DEVTO_API_KEY',
  'GSC_CLIENT_EMAIL',
  'GSC_PRIVATE_KEY',
  'GSC_SITE_URL',
  'CONVERSION_VALUE_USD'
];
for (const env of REQUIRED_ENVS) {
  if (!process.env[env]) {
    throw new Error(`Missing required env var: ${env}`);
  }
}

// Initialize Dev.to API client
const devto = new DevToApi({
  apiKey: process.env.DEVTO_API_KEY,
  baseUrl: 'https://api.dev.to/api/v2',
});

// Initialize Google Search Console client
const gscAuth = new google.auth.GoogleAuth({
  credentials: {
    client_email: process.env.GSC_CLIENT_EMAIL,
    private_key: process.env.GSC_PRIVATE_KEY.replace(/\\n/g, '\n'),
  },
  scopes: ['https://www.googleapis.com/auth/webmasters.readonly'],
});
const searchconsole = google.searchconsole({
  version: 'v1',
  auth: gscAuth,
});

// Fetch Dev.to analytics for a post (2026 API includes referrer and conversion data)
async function fetchDevToAnalytics(postId) {
  return new Promise((resolve, reject) => {
    retryRequest(async () => {
      const response = await devto.articles.getAnalytics(postId, {
        start_date: '2026-01-01',
        end_date: '2026-03-31',
      });
      if (response.status !== 200) {
        reject(new Error(`Dev.to API error: ${response.status}`));
        return;
      }
      resolve(response.data);
    }).catch(reject);
  });
}

// Fetch Google Search Console data for a canonical URL
async function fetchGSCData(canonicalUrl) {
  try {
    const response = await searchconsole.searchanalytics.query({
      siteUrl: process.env.GSC_SITE_URL,
      requestBody: {
        startDate: '2026-01-01',
        endDate: '2026-03-31',
        dimensions: ['query'],
        dimensionFilterGroups: [{
          filters: [{
            dimension: 'page',
            expression: canonicalUrl,
          }]
        }],
        rowLimit: 1000,
      },
    });
    return response.data.rows || [];
  } catch (err) {
    console.error(`GSC fetch failed for ${canonicalUrl}: ${err.message}`);
    return [];
  }
}

// Retry logic for API rate limits
async function retryRequest(requestFn, maxRetries = 3, delayMs = 1000) {
  let lastError;
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await requestFn();
    } catch (err) {
      lastError = err;
      if (err.response?.status === 429 || err.response?.status >= 500) {
        await new Promise(resolve => setTimeout(resolve, delayMs * (i + 1)));
        continue;
      }
      throw err;
    }
  }
  throw lastError;
}

// Calculate attribution for a single post
async function calculatePostAttribution(post) {
  const { devtoId, canonicalUrl, title } = post;
  const conversionValue = parseFloat(process.env.CONVERSION_VALUE_USD);

  // Fetch Dev.to data
  const devtoAnalytics = await fetchDevToAnalytics(devtoId);
  const devtoReferrals = devtoAnalytics.referrals || 0;
  const devtoConversions = devtoAnalytics.conversions || 0;

  // Fetch GSC data
  const gscRows = await fetchGSCData(canonicalUrl);
  const gscClicks = gscRows.reduce((sum, row) => sum + row.clicks, 0);
  const gscConversions = Math.round(gscClicks * 0.02); // 2% conversion rate for organic search

  // Total attribution
  const totalConversions = devtoConversions + gscConversions;
  const totalValue = totalConversions * conversionValue;

  return {
    title,
    devtoId,
    canonicalUrl,
    devtoReferrals,
    devtoConversions,
    gscClicks,
    gscConversions,
    totalConversions,
    totalValueUSD: totalValue,
  };
}

// Main execution
(async () => {
  try {
    // Load post manifest (same as first script)
    const manifestPath = path.resolve('post-manifest.json');
    const rawManifest = await fs.readFile(manifestPath, 'utf-8');
    const posts = JSON.parse(rawManifest);

    const results = [];
    for (const post of posts) {
      console.log(`Calculating attribution for ${post.title}...`);
      const attribution = await calculatePostAttribution(post);
      results.push(attribution);
    }

    // Write results
    const outputPath = path.resolve('attribution-results.json');
    await fs.writeFile(outputPath, JSON.stringify(results, null, 2));
    console.log(`Attribution results written to ${outputPath}`);

    // Summary
    const totalValue = results.reduce((sum, r) => sum + r.totalValueUSD, 0);
    console.log(`Total attributed pipeline value: $${totalValue.toFixed(2)}`);
  } catch (err) {
    console.error(`Fatal error: ${err.message}`);
    process.exit(1);
  }
})();

# Fetch top 10 tags for "nodejs" with follower count
curl -H "api-key: $DEVTO_API_KEY" \
  "https://api.dev.to/api/v2/tags?search=nodejs&limit=10" \
  | jq '.[] | {name: .name, follower_count: .follower_count}'

# .markdownlint.yml rule to require code block language
MD040:
  enabled: true
  language: ".*" # Requires non-empty language for fenced code blocks

# Post frontmatter example
title: "60% Blog Traffic Boost with Dev.to 2026 SEO"
description: "Learn how we drove 60% more blog traffic using Dev.to 2026 features and SEO optimizations across 50+ posts"
canonicalUrl: "https://engineering.ourcompany.com/blog/60-percent-traffic-boost-devto-2026-seo"
tags: ["devto", "seo", "nodejs", "technicalwriting"]