# Dev.to Articles Scraper (`logiover/devto-articles-scraper`) Actor

Scrape developer articles from Dev.to by tag or author: title, description, tags, reactions, comments and reading time. Schedule it to track trending tech content and topics.

- **URL**: https://apify.com/logiover/devto-articles-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** News, Developer tools
- **Stats:** 40 total users, 15 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ✍️ Dev.to Articles Scraper — Developer Blog Posts by Tag or Author to JSON/CSV

Scrape **developer articles from [Dev.to](https://dev.to)** straight from its official public API — pull posts by tag or author with full metadata and paginate the entire feed. This **Dev.to scraper** extracts title, description, tags, reactions, comments and reading time, and exports everything to JSON, CSV or Excel. **No login, no API key, no blocking.**

Dev.to publishes thousands of new technical articles every week. Built for **scheduled, recurring use**, this Actor keeps you supplied with the latest developer content — perfect for trend research, newsletters, dev-relations monitoring and building structured content datasets.

### ✨ What this Actor does / Key features

- **Official Dev.to API** — fast, reliable and fully paginated; no fragile HTML parsing.
- **Filter by tag** — pull articles for a specific topic such as `javascript`, `ai`, `webdev`, `python` or `react`.
- **Filter by author** — collect all articles from a specific Dev.to writer by username.
- **Rich metadata per article** — title, description, URL, author name and username, tags, reactions count, comments count, reading time, cover image and publish date.
- **Full pagination** — crawls the entire feed for your filter, not just the first page.
- **Adjustable run size** — set `maxArticles` to cap the run, or `0` to pull every available article.
- **No API key, no login** — pure public-API access, no authentication required.
- **Structured, export-ready output** — flat JSON records, ideal for JSON, CSV, Excel, databases or BI tools.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `tag` | string | Filter by tag, e.g. `javascript`, `ai`, `webdev`. Leave empty for the latest articles across all tags. |
| `username` | string | Filter to a specific author's articles by their Dev.to username. Optional. |
| `maxArticles` | integer | Maximum number of articles to save. `0` = all available. Minimum `0`. |

### 🚀 Example input

```json
{
  "tag": "javascript",
  "maxArticles": 0
}
````

Collect all articles from a specific author:

```json
{
  "username": "ben",
  "maxArticles": 200
}
```

### 📦 Output

Each item in the dataset is one Dev.to article. Output is flat, structured JSON — easy to export to CSV or Excel or push into a database.

| Field | Description |
|-------|-------------|
| `id` | Unique Dev.to article ID. |
| `title` | Article title. |
| `description` | Short article description / summary. |
| `url` | Full URL of the article on Dev.to. |
| `author` | Display name of the author. |
| `authorUsername` | Dev.to username of the author. |
| `tags` | Array of tags attached to the article. |
| `commentsCount` | Number of comments on the article. |
| `reactionsCount` | Total reactions (likes, unicorns, bookmarks, etc.). |
| `readingTimeMinutes` | Estimated reading time in minutes. |
| `coverImage` | URL of the article's cover image. |
| `publishedAt` | Publication date/time of the article. |
| `scrapedAt` | ISO timestamp of when the record was scraped. |

#### Example output record

```json
{
  "id": 1234567,
  "title": "10 JavaScript Tricks You Should Know",
  "description": "A practical roundup of modern JS techniques.",
  "url": "https://dev.to/example/10-javascript-tricks-you-should-know",
  "author": "Jane Developer",
  "authorUsername": "janedev",
  "tags": ["javascript", "webdev", "beginners"],
  "commentsCount": 24,
  "reactionsCount": 312,
  "readingTimeMinutes": 6,
  "coverImage": "https://res.cloudinary.com/.../cover.png",
  "publishedAt": "2026-05-10T09:00:00Z",
  "scrapedAt": "2026-05-15T08:30:00.000Z"
}
```

### 💡 Use cases

- **Content & trend research** — track what topics the developer community is writing about and which posts gain traction.
- **Newsletters & content aggregators** — keep a curated tech-content feed always fresh and automated.
- **Marketing & developer relations** — monitor mentions of your product, framework or programming language.
- **Datasets & NLP** — build a structured corpus of developer articles for analysis or model training.
- **Competitive analysis** — see what content competitors and influential authors are publishing and how it performs.

### ❓ Frequently Asked Questions

**Do I need a Dev.to API key or login?**
No. The Actor uses Dev.to's public API and requires no API key, account or login.

**Is it legal to scrape Dev.to?**
The Actor reads publicly available articles via Dev.to's official public API, which is intended for programmatic access. You are responsible for complying with Dev.to's terms of service and for how you use the data.

**How many articles can I get?**
The Actor paginates the entire feed for your chosen filter. Set `maxArticles` to `0` for everything available, or a smaller number for a faster, capped run.

**Can I filter by topic or author?**
Yes. Use `tag` to filter by topic (e.g. `javascript`, `ai`, `webdev`) and `username` to collect a specific author's articles. You can use either, or leave both empty for the latest across all tags.

**Does the output include engagement metrics?**
Yes — every record includes `reactionsCount`, `commentsCount` and `readingTimeMinutes`, so you can rank or analyze articles by popularity.

**How fast is it and how much does it cost?**
It runs as fast, plain API requests and completes quickly. Cost depends only on the small amount of Apify compute used; there are no third-party fees.

**Can I schedule it and what output formats are supported?**
Yes — schedule it on Apify to run daily for a continuously updated feed. Results export to JSON, CSV, Excel or XML, or via the Apify API.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to run daily for a continuously updated developer-articles feed. Export results to JSON, CSV or Excel, pull them through the Apify API, or connect the dataset to Google Sheets, webhooks or your newsletter and content pipelines.

# Actor input Schema

## `tag` (type: `string`):

Filter by tag, e.g. 'javascript', 'ai', 'webdev'. Leave empty for the latest articles across all tags.

## `username` (type: `string`):

Filter to a specific author's articles. Optional.

## `maxArticles` (type: `integer`):

Maximum articles to save. 0 = all.

## Actor input object example

```json
{
  "tag": "",
  "username": ""
}
```

# Actor output Schema

## `title` (type: `string`):

title

## `author` (type: `string`):

author

## `tags` (type: `string`):

tags

## `reactionsCount` (type: `string`):

reactionsCount

## `commentsCount` (type: `string`):

commentsCount

## `url` (type: `string`):

url

## `publishedAt` (type: `string`):

publishedAt

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/devto-articles-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("logiover/devto-articles-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call logiover/devto-articles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/devto-articles-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dev.to Articles Scraper",
        "description": "Scrape developer articles from Dev.to by tag or author: title, description, tags, reactions, comments and reading time. Schedule it to track trending tech content and topics.",
        "version": "1.0",
        "x-build-id": "WPUgUvoXTTWeUfS6e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~devto-articles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-devto-articles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~devto-articles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-devto-articles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~devto-articles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-devto-articles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tag": {
                        "title": "Tag",
                        "type": "string",
                        "description": "Filter by tag, e.g. 'javascript', 'ai', 'webdev'. Leave empty for the latest articles across all tags.",
                        "default": ""
                    },
                    "username": {
                        "title": "Username",
                        "type": "string",
                        "description": "Filter to a specific author's articles. Optional.",
                        "default": ""
                    },
                    "maxArticles": {
                        "title": "Max Articles",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum articles to save. 0 = all."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
