# Wired Rss Scraper (`real-estate-api/wired-rss-scraper`) Actor

Wired RSS Scraper is a Python tool designed to parse and extract news articles, titles, publication dates, author details, and full text from Wired RSS feeds. It exports structured technology news data into clean CSV or JSON formats for media monitoring and content analysis.

- **URL**: https://apify.com/real-estate-api/wired-rss-scraper.md
- **Developed by:** [real-estate-api](https://apify.com/real-estate-api) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## WIRED RSS Scraper: Export Headlines to JSON or CSV

<p align="center">
  <img src="https://imgur.com/99CiYWM.png" alt="WIRED RSS Scraper" width="800" />
</p>

WIRED RSS Scraper collects headlines, story links, publication dates, authors, categories, and short summaries from public WIRED RSS feeds. Export results to JSON, CSV, or Excel for news monitoring, research, and scheduled updates.

The feeds contain recent stories rather than the full archive. For ongoing monitoring, schedule regular runs and use the `guid` field to identify stories already processed.

### Use Cases

- **News monitoring:** Collect the latest WIRED headlines on a schedule.
- **Section monitoring:** Track a specific section, such as business.
- **Keyword filtering:** Keep stories whose headlines or summaries contain a specified keyword.
- **Research lists:** Export story links, publication dates, and summaries.
- **Duplicate detection:** Use story identifiers to avoid processing the same item repeatedly.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `feedUrls` | Array | Main feed and business feed | WIRED RSS feed URLs, one per entry. Other sites are rejected. |
| `keyword` | String | Empty | Optional filter applied to headlines and summaries. |
| `maxItems` | Integer | `100` | Maximum number of story rows per run. Hard limit: `1000`. |
| `timeoutSecs` | Integer | `300` | Overall run time limit in seconds. |
| `requestTimeoutSecs` | Integer | `30` | Timeout for an individual request in seconds. |

### Example Input

Replace the placeholders with the WIRED RSS feed URLs you want to monitor.

```json
{
  "feedUrls": [
    "WIRED_MAIN_RSS_FEED_URL",
    "WIRED_BUSINESS_RSS_FEED_URL"
  ],
  "keyword": "",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

### What Data Does This Actor Extract?

Each story is saved as a separate dataset row. Headlines are stored in `itemTitle`, and summaries are stored in `summaryText`. Summaries are converted to plain text and trimmed to a maximum of 500 characters. Full article HTML and article bodies are not collected.

#### Example Output

```json
{
  "itemTitle": "Example WIRED Story Headline",
  "link": "STORY_URL",
  "guid": "example-story-identifier",
  "pubDate": "Sun, 11 Oct 2026 11:30:00 +0000",
  "summaryText": "A short plain-text summary of the story.",
  "categories": [
    "Gear",
    "Gear / Gear News and Events"
  ],
  "author": "Example Author",
  "imageUrl": "IMAGE_URL",
  "scrapedAt": "2026-10-12T00:00:00+00:00"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `itemTitle` | String | Story headline. |
| `link` | String | Story URL. |
| `guid` | String | Feed identifier used for deduplication. Falls back to the story link if unavailable. |
| `pubDate` | String or null | Publication date provided by the feed. |
| `summaryText` | String or null | Short, plain-text story summary. |
| `categories` | Array | Category labels associated with the story. |
| `author` | String or null | Author, when provided by the feed. |
| `imageUrl` | String or null | Media or enclosure image URL, when available. |
| `scrapedAt` | String | UTC timestamp when the row was saved. |
| `error` | String | Error description for a failed input instead of a story record. |
| `input` | String | URL or setting associated with a failed input. |

### How It Works

1. Reads the configured feed list, optional keyword, and maximum item count.
2. Checks that each feed belongs to an accepted WIRED RSS feed pattern.
3. Requests the configured feeds and parses their RSS items.
4. Removes HTML from text fields, filters stories by keyword when specified, and removes duplicate story identifiers.
5. Stops when the configured item limit is reached.
6. Saves story records and error details to the dataset.

#### Retries and Error Handling

- HTTP 429 responses, server errors (5xx), and timeouts are retried up to three times.
- Retry delays are 2, 4, and 8 seconds, with short `Retry-After` delays respected when provided.
- Invalid feed URLs, non-XML responses, and HTTP errors produce rows containing `error` and `input`.
- A failed feed does not prevent the actor from attempting other configured feeds.

#### Feed and Rate Limits

- RSS feeds provide recent items; they do not provide a complete historical archive.
- Each feed is processed as a single page, without backward pagination.
- Schedule polls approximately 5–15 minutes apart for the same feed.
- The source may expose request-limit information in its response headers. If the remaining request allowance reaches zero, additional requests in that run are skipped after the current response is saved.

### Limits and Terms

WIRED's user agreement specifies conditions for personal and non-commercial use. This actor stores headlines, links, dates, author information, image URLs, and short summaries rather than downloading full article bodies.

You are responsible for ensuring that your use of exported data complies with applicable source terms, copyright requirements, attribution rules, and other relevant restrictions.

**Pricing:** The actor is free to run. Normal Apify platform usage charges may apply.

### FAQ

#### Can I export results to CSV or JSON?

Yes. Dataset results can be exported in JSON, CSV, and Excel formats.

#### Does it collect older stories?

No. The feeds provide recent items, not a complete archive. Schedule repeated runs and use `guid` to identify new stories and avoid duplicates.

#### What happens if a feed URL is invalid?

The actor saves an error row for the invalid input and continues processing other configured feeds.

#### What is the maximum number of items per run?

The default is `100`, and the maximum is `1000`.

#### Does the actor download full articles?

No. It collects feed metadata and short summaries, not full article bodies.

### Trademark Notice

WIRED and related names, logos, and trademarks belong to their respective owners. Their use in this documentation is solely to identify the source of the data and does not imply affiliation, sponsorship, endorsement, or partnership.

### Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, sponsored by, or officially associated with WIRED or its owners. Users are responsible for complying with applicable source terms, rate limits, attribution requirements, and licensing restrictions.

### Is Web Scraping Legal?

Collecting information that is already public is generally legal. Scraping is not the same thing as hacking, and there is no single law that bans it. The limits are the usual ones: do not break into accounts, do not take private or confidential data, and be careful with personal data and copyrighted works. A site's terms can also restrict how you access it. Facts such as a public name, price, or rating are not the same thing as republishing someone's article or photo.

This actor collects information from public pages. It does not log in and it does not bypass access controls.

For a longer explanation, see Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `feedUrls` (type: `array`):

WIRED RSS feed URLs to read. Use the main feed or a category latest feed on www.wired.com. One URL per line.

## `keyword` (type: `string`):

Optional case-insensitive filter applied to the headline and short summary. Leave empty to keep every item.

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

Maximum number of story rows to save in one run. Values are clamped between 1 and 1000.

## `timeoutSecs` (type: `integer`):

Maximum seconds the run may spend fetching feeds before it stops and saves what it has.

## `requestTimeoutSecs` (type: `integer`):

Maximum seconds to wait for a single feed response before retrying or recording an error.

## `proxyConfiguration` (type: `object`):

Optional proxy for feed requests. Leave Apify Proxy off unless the feed blocks your IP.

## Actor input object example

```json
{
  "feedUrls": [
    "https://www.wired.com/feed/rss",
    "https://www.wired.com/feed/category/business/latest/rss"
  ],
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `datasetUrl` (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 = {
    "feedUrls": [
        "https://www.wired.com/feed/rss",
        "https://www.wired.com/feed/category/business/latest/rss"
    ],
    "keyword": "",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("real-estate-api/wired-rss-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 = {
    "feedUrls": [
        "https://www.wired.com/feed/rss",
        "https://www.wired.com/feed/category/business/latest/rss",
    ],
    "keyword": "",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("real-estate-api/wired-rss-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "feedUrls": [
    "https://www.wired.com/feed/rss",
    "https://www.wired.com/feed/category/business/latest/rss"
  ],
  "keyword": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call real-estate-api/wired-rss-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,real-estate-api/wired-rss-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IekM6mPg1jpL6fmpl/builds/K1yekUghRnGrRXK86/openapi.json