# Lobste.rs Scraper (`resounding_diplomacy/lobste-rs-scraper`) Actor

Scrapes Lobste.rs tech news aggregator - stories, comments, and metadata. Get titles, URLs, scores, tags, and discussion counts from this niche but active tech community. Perfect complement to Hacker News scraping.

- **URL**: https://apify.com/resounding\_diplomacy/lobste-rs-scraper.md
- **Developed by:** [alars num](https://apify.com/resounding_diplomacy) (community)
- **Categories:** News, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Lobste.rs Scraper

Scrape Lobste.rs tech news aggregator - stories, comments, and metadata. Extract titles, URLs, scores, tags, comment counts, submitter info, and timestamps from this niche but active tech community. Perfect complement to Hacker News scraping for comprehensive tech news coverage.

This actor uses CheerioCrawler for fast HTTP-based scraping, supports multiple modes (hot, newest, comments), tag filtering, score filtering, and automatic pagination. No API key or authentication required.

### Features

- Scrape hot stories, newest submissions, or recent comments from Lobste.rs
- Filter stories by tags (e.g., 'programming', 'rust', 'linux')
- Filter by minimum score threshold
- Sort results by hot (default algorithm), newest (chronological), or top (by score)
- Extracts story ID, title, source URL, Lobste.rs URL, score, comment count, submitter, tags, timestamp, and description
- Auto-detects Hacker News links for cross-platform tracking
- Automatic pagination to collect more items
- No API key, authentication, or login required

### Input

Configure the actor through the input schema. All fields are optional with sensible defaults.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | String | `main` | Scraping mode: `main` (hot stories), `newest` (newest submissions), or `comments` (recent comments) |
| `maxItems` | Integer | `30` | Maximum number of stories/comments to scrape |
| `sortBy` | String | `hot` | Sort order: `hot` (algorithmic), `newest` (chronological), or `top` (by score) |
| `tags` | Array | `[]` | Filter by tags (e.g., `['programming', 'rust']`). Leave empty for all tags |
| `minScore` | Integer | `0` | Only return stories with at least this many upvotes |
| `includeTags` | Boolean | `true` | Include tag information in the output |

#### Example input

```json
{
    "mode": "main",
    "maxItems": 50,
    "sortBy": "hot",
    "tags": ["programming", "rust"],
    "minScore": 5,
    "includeTags": true
}
````

### Output

Results are stored in the default dataset and can be exported as JSON, CSV, Excel, or via API.

#### Story output format

```json
{
    "story_id": "abc123",
    "title": "Rust for Embedded Systems",
    "url": "https://example.com/rust-embedded",
    "lobste_rs_url": "https://lobste.rs/s/abc123",
    "score": 42,
    "comment_count": 15,
    "submitter": "rustacean",
    "tags": ["programming", "rust", "embedded"],
    "submitted_at": "2026-07-04T10:23:00Z",
    "is_hn_link": false,
    "description": "An introduction to using Rust..."
}
```

#### Output fields

| Field | Description |
|-------|-------------|
| `story_id` | Unique story identifier from Lobste.rs |
| `title` | Story title |
| `url` | Original source URL |
| `lobste_rs_url` | Lobste.rs discussion URL |
| `score` | Number of upvotes |
| `comment_count` | Number of comments |
| `submitter` | Username of the submitter |
| `tags` | Array of tags associated with the story |
| `submitted_at` | ISO 8601 timestamp when submitted |
| `is_hn_link` | Boolean indicating if story links to Hacker News |
| `description` | Story description or excerpt (if available) |

### Use cases

- **Tech news aggregation** — Combine with Hacker News scraper for comprehensive tech news coverage
- **Community monitoring** — Track discussions in the Rust, Linux, and broader developer communities
- **Content discovery** — Find high-quality technical articles and blog posts
- **Trend analysis** — Identify emerging trends in programming languages and tools
- **Competitive intelligence** — Monitor competitor launches and community reactions
- **Lead generation** — Identify active developers and companies in niche tech communities
- **Tag-based filtering** — Focus on specific topics like 'programming', 'rust', 'linux', 'databases'

### How to use

1. Open the actor on the [Apify Store](https://apify.com/store).
2. Click **Try for free** or **Start with Free Trial**.
3. Adjust the input fields (mode, max items, tags, sort order, min score) — or leave defaults.
4. Click **Start** and wait for the run to complete.
5. Export the results to JSON, CSV, or connect via the Apify API.

For scheduled runs, use Apify's scheduler to scrape Lobste.rs daily or weekly and auto-export to your webhook, database, or Google Sheets.

### Tech News Bundle

Pair this actor with the [Hacker News Scraper](https://apify.com/store) for a complete tech news bundle:

- **Hacker News Scraper** — Mainstream tech news, startups, and Silicon Valley discussions
- **Lobste.rs Scraper** — Niche technical discussions, programming language deep-dives, and hands-on engineering content

Run both in parallel via Apify's task scheduler or webhook integrations for comprehensive coverage.

### About Lobste.rs

Lobste.rs is a tech-focused link aggregator similar to Hacker News but with a more technical and hands-on focus. It's particularly strong in discussions about programming languages, systems programming, and practical engineering topics. The community is smaller (3.9M+ runs on existing scrapers) but highly engaged and technically sophisticated.

# Actor input Schema

## `mode` (type: `string`):

Scraping mode: main (hot stories), newest (newest submissions), or comments (recent comments)

## `maxItems` (type: `integer`):

Maximum number of stories/comments to scrape

## `sortBy` (type: `string`):

Sort results: hot (default algorithm), newest (chronological), or top (by score)

## `tags` (type: `array`):

Filter by tags (e.g., 'programming', 'rust', 'linux'). Leave empty for all tags.

## `minScore` (type: `integer`):

Only return stories with at least this many upvotes

## `includeTags` (type: `boolean`):

Include tag information in the output

## Actor input object example

```json
{
  "mode": "main",
  "maxItems": 30,
  "sortBy": "hot",
  "tags": [],
  "minScore": 0,
  "includeTags": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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("resounding_diplomacy/lobste-rs-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("resounding_diplomacy/lobste-rs-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 resounding_diplomacy/lobste-rs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lobste.rs Scraper",
        "description": "Scrapes Lobste.rs tech news aggregator - stories, comments, and metadata. Get titles, URLs, scores, tags, and discussion counts from this niche but active tech community. Perfect complement to Hacker News scraping.",
        "version": "1.0",
        "x-build-id": "NzoyjmafUlIB4VfaO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/resounding_diplomacy~lobste-rs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-resounding_diplomacy-lobste-rs-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/resounding_diplomacy~lobste-rs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-resounding_diplomacy-lobste-rs-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/resounding_diplomacy~lobste-rs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-resounding_diplomacy-lobste-rs-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "main",
                            "newest",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Scraping mode: main (hot stories), newest (newest submissions), or comments (recent comments)",
                        "default": "main"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of stories/comments to scrape",
                        "default": 30
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "hot",
                            "newest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Sort results: hot (default algorithm), newest (chronological), or top (by score)",
                        "default": "hot"
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "array",
                        "description": "Filter by tags (e.g., 'programming', 'rust', 'linux'). Leave empty for all tags.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minScore": {
                        "title": "Minimum Score",
                        "type": "integer",
                        "description": "Only return stories with at least this many upvotes",
                        "default": 0
                    },
                    "includeTags": {
                        "title": "Include Tags",
                        "type": "boolean",
                        "description": "Include tag information in the output",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
