# The Daily Affairs Article Scraper (`solidcode/dailyaffairs-scraper`) Actor

\[💰 $5.00 / 1K] Scrape article details from The Daily Affairs (dailyaffairs.org). Paste article URLs and get clean structured data — title, summary, author, and publication date — exported to JSON, CSV, or Excel. No code, no API key.

- **URL**: https://apify.com/solidcode/dailyaffairs-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** News, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## The Daily Affairs Article Scraper

Turn any list of The Daily Affairs article links into clean, structured data — headline, full plain-text body, summary, author, category, lead image, and an ISO-8601 publish date, one tidy row per article. Paste the URLs, run once, and get a spreadsheet-ready dataset back. Built for media monitors, content teams, and news researchers who need dependable article data from The Daily Affairs without copy-pasting stories by hand.

### Why This Scraper?

- **9 structured fields per article, not 5** — headline, full plain-text body, summary, author, category, lead image URL, ISO-8601 publish date, URL slug, plus the source URL echoed back. Comparable scrapers ship a thin five-field row.
- **Full article body as clean plain text** — the complete story, with formatting stripped and paragraphs joined, ready to drop straight into NLP pipelines, LLM training sets, or a reader — not just a headline and a one-line blurb.
- **Purpose-built for India current-affairs** — tuned to The Daily Affairs' AI-curated Indian news across politics, business, crime, and world sections.
- **Category tag on every row** — each article carries its section (politics, business, crime, …) so you can filter, group, and trend by topic with no post-processing.
- **ISO-8601 UTC timestamps** — every `publishedAt` is normalized to `YYYY-MM-DDTHH:MM:SSZ`, so records sort and join cleanly no matter how the source formats dates.
- **Lead image URL on every article** — the featured image link comes through ready to embed in dashboards, newsletters, or archives.
- **Source URL echoed on every record** — the exact URL you pasted returns on the row, making joins, dedup, and audits trivial (rival outputs drop it entirely).
- **Clean field names, zero noise** — consistent, predictable output with no leaked internal bookkeeping IDs, from $5.00 per 1,000 results — roughly 44% below the closest comparable article scraper.

### Use Cases

**Media Monitoring & PR**
- Track how The Daily Affairs covers your brand, executives, or sector across Indian current affairs
- Archive full-text articles by category for stakeholder and press-clipping reports
- Feed new stories into your alerting workflow the moment you collect them

**Content Aggregation & Curation**
- Pull full article bodies to power topic newsletters or a curated India-news digest
- Build a category-filtered feed (politics, business, crime) for a niche audience
- Repurpose summaries and lead images into social or email content, respecting copyright

**Research & Academia**
- Assemble full-text corpora of Indian current-affairs reporting for NLP or discourse analysis
- Study how specific events are framed, using clean body text and publish timestamps
- Build longitudinal datasets keyed on category and publication date

**AI & LLM Training Data**
- Collect clean, plain-text article bodies as fine-tuning or retrieval source material
- Label training sets by topic straight from the `category` field
- Gather timestamped, deduplicated news text without manual copy-paste

**Newsroom & Competitive Intelligence**
- Monitor a competitor publisher's output and framing, category by category
- Capture bylines and publish times to map who covers what, and when
- Keep a structured, searchable archive of the stories you care about

### Getting Started

#### Single Article

The minimum input — one article URL:

```json
{
    "articleUrls": [
        "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows"
    ]
}
````

#### Several Articles at Once

Paste as many links as you like, one per line:

```json
{
    "articleUrls": [
        "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows",
        "https://dailyaffairs.org/article/monsoon-forecast-above-normal-rainfall",
        "https://dailyaffairs.org/article/parliament-winter-session-key-bills"
    ]
}
```

#### Batch With a Cap

Provide a long list but stop after a set number of articles — perfect for a quick sample:

```json
{
    "articleUrls": [
        "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows",
        "https://dailyaffairs.org/article/monsoon-forecast-above-normal-rainfall",
        "https://dailyaffairs.org/article/parliament-winter-session-key-bills",
        "https://dailyaffairs.org/article/startup-funding-winter-continues"
    ],
    "maxResults": 2
}
```

### Input Reference

#### Articles

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `articleUrls` | array | one example URL | The Daily Affairs article page URLs to collect, one per line (e.g. `https://dailyaffairs.org/article/<slug>`). Each URL returns exactly one article in the output. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `0` | Maximum number of articles to collect in this run. Set to `0` (or leave empty) for no limit — every URL you provide is collected. |

### Output

Each record is one article with 9 structured fields, in a single flat row:

```json
{
    "url": "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows",
    "title": "Rupee Plummets Amid Adani Scrutiny and Offshore Outflows",
    "summary": "The Indian rupee slid to a record low against the dollar as renewed scrutiny of the Adani Group and steady foreign outflows weighed on market sentiment.",
    "author": "Priya Nair",
    "publishedAt": "2026-02-11T09:30:00Z",
    "content": "The Indian rupee fell to a fresh record low on Tuesday as pressure mounted on domestic equities.\n\nForeign portfolio investors pulled steadily out of Indian markets through the week.\n\nAnalysts said the central bank was likely to step in to smooth the currency's decline.",
    "category": "business",
    "imageUrl": "https://cdn.dailyaffairs.org/images/rupee-record-low.jpg",
    "slug": "rupee-plummets-amid-adani-scrutiny-offshore-outflows"
}
```

#### Fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | The article URL you provided, echoed back on the record. |
| `title` | string | Article headline. |
| `summary` | string | null | Short article summary / standfirst. |
| `author` | string | null | Byline / author name. |
| `publishedAt` | string (ISO 8601) | null | Publication date-time in UTC (`YYYY-MM-DDTHH:MM:SSZ`). |
| `content` | string | null | Full article body as clean plain text, paragraphs separated by blank lines. |
| `category` | string | null | Article section (e.g. politics, business, crime). |
| `imageUrl` | string | null | Lead / featured image URL. |
| `slug` | string | null | The article's URL slug identifier. |

### Tips for Best Results

- **Paste many URLs in one run** — your whole list is collected together, so a single run with hundreds of links is far faster and cheaper to manage than many one-URL runs.
- **Find article URLs from the site's category pages** — browse a section on dailyaffairs.org, open the stories you want, and copy each article link from your browser's address bar.
- **URLs are forgiving** — trailing slashes, query strings, and `#fragments` are all handled; you can even paste a bare article slug on its own and it still resolves.
- **Mix in non-article links safely** — homepage, category, and other non-article URLs are skipped with a friendly note, so a rough copy-paste of links won't break the run.
- **`content` is ready to use as-is** — the body arrives as clean plain text with paragraphs separated by blank lines, so there's nothing to clean up before analysis.
- **Use `maxResults` to preview quality** — set it to a small number to sample field quality on a big list before committing to the full collection.
- **Sort by `publishedAt` for freshness** — it's normalized ISO-8601 UTC, ideal for ordering newest-first or filtering to a specific date window.

### Pricing

**From $5.00 per 1,000 results** — roughly 44% below the closest comparable article scraper. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

Each successfully collected article counts as one result. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate media monitoring, content curation, and research. You are responsible for complying with applicable laws and The Daily Affairs' Terms of Service. Respect copyright when redistributing article text, summaries, or images, credit the original publisher, and do not use collected data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `articleUrls` (type: `array`):

The Daily Affairs article page URLs to scrape, one per line (for example https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows). Each URL returns one article in the output.

## `maxResults` (type: `integer`):

Maximum number of articles to collect in this run. Set to 0 to collect every URL you provided (no limit).

## Actor input object example

```json
{
  "articleUrls": [
    "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped articles with key fields — title, category, author, publication date, and URL.

# 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 = {
    "articleUrls": [
        "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows"
    ],
    "maxResults": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/dailyaffairs-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 = {
    "articleUrls": ["https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows"],
    "maxResults": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/dailyaffairs-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 '{
  "articleUrls": [
    "https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows"
  ],
  "maxResults": 0
}' |
apify call solidcode/dailyaffairs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Daily Affairs Article Scraper",
        "description": "[💰 $5.00 / 1K] Scrape article details from The Daily Affairs (dailyaffairs.org). Paste article URLs and get clean structured data — title, summary, author, and publication date — exported to JSON, CSV, or Excel. No code, no API key.",
        "version": "1.0",
        "x-build-id": "xGaof5aAcv4cwaDEb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~dailyaffairs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-dailyaffairs-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/solidcode~dailyaffairs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-dailyaffairs-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/solidcode~dailyaffairs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-dailyaffairs-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": {
                    "articleUrls": {
                        "title": "Article URLs",
                        "type": "array",
                        "description": "The Daily Affairs article page URLs to scrape, one per line (for example https://dailyaffairs.org/article/rupee-plummets-amid-adani-scrutiny-offshore-outflows). Each URL returns one article in the output.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Articles",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of articles to collect in this run. Set to 0 to collect every URL you provided (no limit)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
