# Bloomberg News Scraper (Cheap) (`data_api/bloomberg-news-scraper-cheap`) Actor

Bloomberg news scraper that pulls headlines, body text, authors, and tags from article and section pages, so your data pipelines get financial news without the copy-paste.

- **URL**: https://apify.com/data\_api/bloomberg-news-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (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 $3.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Bloomberg News Scraper

Copying Bloomberg stories into a spreadsheet by hand does not scale, and the page markup changes often enough to break a quick script. Paste a list of article links and this scraper hands back a tidy row per story: the headline, the full body text, who wrote it, when it ran, the topic tags, and the lead photo. Feed it two URLs or a few hundred and pipe the clean output straight into your research, monitoring, or NLP workflow.

![Bloomberg News Scraper](cover.jpg)

### What you get

One row per article, with the same column layout every time. Anything the page does not expose comes back as `null`, so your sheet or database stays rectangular. Each record covers four groups:

- **Story** — `articleTitle`, `seoTitle`, `summaryText`, `articleBody`, `storyId`, `urlSlug`, `readMinutes`
- **Credits** — `bylineText`, `writerName`, `writerTwitter`
- **Classification** — `sectionName`, `categoryList`, `topicTags`, `paywalled`
- **Media and dates** — `imageLink`, `captionText`, `photoCredit`, `publishedDate`, `updatedDate`, `collectedAt`, plus `articleUrl` and `errorMessage`

### Quick start

1. Open the actor and click **Try for free** to bring up the input form.
2. Paste one or more Bloomberg article links into **Article URLs** (use the full `/news/articles/...` address — query strings are stripped for you).
3. Set a **Results limit** to cap the run and raise **Timeout (seconds)** if pages load slowly.
4. Press **Start**, then download the dataset as JSON, CSV, Excel, or XML when the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Market and equity research** — pull a batch of stories on a sector or ticker and run sentiment or topic analysis over the whole set
- **News monitoring** — refresh a fixed list of article links on a schedule and watch the `updatedDate` field for edits
- **Editorial and competitive intelligence** — filter by `sectionName`, `topicTags`, or `writerName` to see what Bloomberg is covering and who is covering it
- **Data journalism** — collect authorship and publication patterns across hundreds of stories for an investigation
- **NLP and dataset building** — assemble a clean, structured corpus of financial reporting to train or evaluate models
- **Internal dashboards** — feed the structured rows into Slack alerts, BigQuery, or a reporting dashboard

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `articleUrls` | array of strings | Yes | Bloomberg article links to scrape. Each must contain the `/news/articles/...` path; query parameters are removed automatically. |
| `resultsLimit` | integer | No | Largest number of articles a single run will collect, counted across all URLs. Default `40` (1–1000). |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before it is treated as failed. Default `45` (5–120); raise it for slow pages. |

#### Example input

```json
{
    "articleUrls": [
        "https://www.bloomberg.com/news/articles/2026-04-10/fed-officials-signal-patience-on-rate-cuts-amid-sticky-inflation",
        "https://www.bloomberg.com/news/articles/2026-04-11/nvidia-supplier-ramps-output-as-ai-chip-demand-keeps-climbing"
    ],
    "resultsLimit": 40,
    "timeoutSeconds": 45
}
````

### Output

Each input URL becomes one row, and every field is always present — values the page does not expose come back as `null` so the dataset stays rectangular. A row that fails to scrape still appears, with `errorMessage` set and the rest left empty.

#### Example output

```json
{
    "articleUrl": "https://www.bloomberg.com/news/articles/2026-04-11/nvidia-supplier-ramps-output-as-ai-chip-demand-keeps-climbing",
    "storyId": "TFGSTUKK3NYD00",
    "articleTitle": "Nvidia Supplier Ramps Output as AI Chip Demand Keeps Climbing",
    "seoTitle": "Nvidia Supplier Ramps Output as AI Chip Demand Keeps Climbing",
    "bylineText": "Debby Wu",
    "writerName": "Debby Wu",
    "writerTwitter": "debbywu1",
    "publishedDate": "2026-04-11T01:30:56.367Z",
    "updatedDate": "2026-04-11T03:42:27.089Z",
    "summaryText": "A key Nvidia supplier said it is lifting production through the rest of the year as orders for AI accelerators show no sign of cooling.",
    "articleBody": "A key Nvidia supplier said it is lifting production through the rest of the year as orders for AI accelerators show no sign of cooling...",
    "imageLink": "https://assets.bwbx.io/images/users/iqjWHBFdfxIU/itJ0yPa0NDcg/v0/-1x-1.webp",
    "captionText": "A semiconductor fabrication line.",
    "photoCredit": "Photographer: I-Hwa Cheng/Bloomberg",
    "sectionName": "technology",
    "categoryList": "technology",
    "topicTags": "Semiconductors, AI, Nvidia, Supply Chain, Asia",
    "paywalled": false,
    "readMinutes": 2.5,
    "urlSlug": "2026-04-11/nvidia-supplier-ramps-output-as-ai-chip-demand-keeps-climbing",
    "collectedAt": "2026-04-11T05:12:00.000Z",
    "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `articleUrl` | string | Canonical web address of the story |
| `storyId` | string | Bloomberg internal SUID code for the piece |
| `articleTitle` | string | Primary headline shown on the story |
| `seoTitle` | string | Headline variant tuned for search engines |
| `bylineText` | string | Author credit line printed on the article |
| `writerName` | string | Full name of the lead author |
| `writerTwitter` | string | Twitter handle of the lead author, minus the @ |
| `publishedDate` | string | ISO 8601 UTC timestamp of first publication |
| `updatedDate` | string | ISO 8601 UTC timestamp of the latest edit |
| `summaryText` | string | Lede or short summary line for the article |
| `articleBody` | string | Full plain-text of the story; empty when paywalled |
| `imageLink` | string | Address of the lead (lede) photo |
| `captionText` | string | Caption attached to the lead photo |
| `photoCredit` | string | Photographer or agency credited for the lead photo |
| `sectionName` | string | Bloomberg desk: markets, technology, politics, wealth, and similar |
| `categoryList` | string | Section categories as a comma-separated string |
| `topicTags` | string | Content tag names as a comma-separated string |
| `paywalled` | boolean | True when the story sits behind a subscription |
| `readMinutes` | number | Rough reading time in minutes, to one decimal |
| `urlSlug` | string | Date and slug portion of the URL |
| `collectedAt` | string | ISO 8601 UTC timestamp of when the row was captured |
| `errorMessage` | string | Reason a story failed; `null` on success |

### Tips for best results

- **Use full article links.** The path has to contain `/news/articles/` — section or topic landing pages are skipped with a warning in the log.
- **Cap test runs with `resultsLimit`.** Set it to 5–10 while you confirm the columns fit your pipeline, then raise it for the real batch.
- **Raise `timeoutSeconds` to about 60** if you see timeout errors on long stories or during busy periods.
- **Split very large jobs.** For more than a couple hundred links, several runs of 100–200 are steadier than one giant run.
- **Check `paywalled` before reading `articleBody`.** Metadata such as headline, author, and tags still comes back on subscriber-only stories, but the body may be empty.
- **Failures don't stop the run.** A bad link lands in the dataset with `errorMessage` filled in, and the scraper moves on to the next URL.

### How can I use Bloomberg news data?

**How can I use the Bloomberg News Scraper to build a financial news dataset?**
Paste a batch of Bloomberg article links and each one returns the full body text, headline, author, publish date, section, and tags as a single row. Export the lot as JSON or CSV and you have a clean corpus ready for sentiment scoring, topic modeling, or any text-mining project — no manual copy-paste.

**How can I track Bloomberg coverage of a company or market over time?**
Keep a running list of article URLs for the topic you follow and re-run the scraper on a schedule. Filter rows by `topicTags`, `sectionName`, or `writerName` to see how the coverage shifts, and watch `updatedDate` to catch stories Bloomberg has revised after publishing.

**How can I pull Bloomberg article text and metadata for research?**
Drop in one link or several. For each story you get the headline, summary, full text, reading time, lead image, and the credit line in one structured record — enough context for academic work, data journalism, or feeding a downstream news pipeline.

**How can I export Bloomberg articles to CSV or Excel?**
Run the scraper, then open the **Storage** tab and download the dataset in JSON, CSV, Excel, or XML. Every article keeps the same column order, so the file opens cleanly in Sheets, Excel, or a pandas DataFrame.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `startUrls` (type: `array`):

Bloomberg article URLs (https://www.bloomberg.com/news/articles/...). Paste one or more full article URLs to scrape.

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

Maximum number of articles to extract per run. Applies across all start URLs combined.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.bloomberg.com/news/articles/2026-05-22/abrego-garcia-wins-dismissal-of-us-human-smuggling-case",
    "https://www.bloomberg.com/news/articles/2026-05-23/india-raises-diesel-gasoline-prices-for-third-time-in-eight-days"
  ],
  "maxArticles": 50,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "startUrls": [
        "https://www.bloomberg.com/news/articles/2026-05-22/abrego-garcia-wins-dismissal-of-us-human-smuggling-case",
        "https://www.bloomberg.com/news/articles/2026-05-23/india-raises-diesel-gasoline-prices-for-third-time-in-eight-days"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/bloomberg-news-scraper-cheap").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 = { "startUrls": [
        "https://www.bloomberg.com/news/articles/2026-05-22/abrego-garcia-wins-dismissal-of-us-human-smuggling-case",
        "https://www.bloomberg.com/news/articles/2026-05-23/india-raises-diesel-gasoline-prices-for-third-time-in-eight-days",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/bloomberg-news-scraper-cheap").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 '{
  "startUrls": [
    "https://www.bloomberg.com/news/articles/2026-05-22/abrego-garcia-wins-dismissal-of-us-human-smuggling-case",
    "https://www.bloomberg.com/news/articles/2026-05-23/india-raises-diesel-gasoline-prices-for-third-time-in-eight-days"
  ]
}' |
apify call data_api/bloomberg-news-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bloomberg News Scraper (Cheap)",
        "description": "Bloomberg news scraper that pulls headlines, body text, authors, and tags from article and section pages, so your data pipelines get financial news without the copy-paste.",
        "version": "0.0",
        "x-build-id": "8RBWgAqr0DvO6RFav"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~bloomberg-news-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-bloomberg-news-scraper-cheap",
                "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/data_api~bloomberg-news-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-bloomberg-news-scraper-cheap",
                "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/data_api~bloomberg-news-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-bloomberg-news-scraper-cheap",
                "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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Bloomberg article URLs (https://www.bloomberg.com/news/articles/...). Paste one or more full article URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxArticles": {
                        "title": "Max articles",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of articles to extract per run. Applies across all start URLs combined.",
                        "default": 50
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
