# Morningstar Fund & ETF Scraper (`parseforge/morningstar-scraper`) Actor

Scrapes US mutual fund and ETF records from Morningstar by asset type and optional category. Returns each fund as a flat row with the fields available on the public listing.

- **URL**: https://apify.com/parseforge/morningstar-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, News, Lead generation
- **Stats:** 11 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Morningstar Fund & ETF Scraper

**Scrape mutual fund and ETF data from Morningstar, up to a million records per run.** Collect performance metrics, ratings, fees, and category details for US funds and ETFs. Export to CSV, JSON, Excel, or XML.

Morningstar's website is the standard for fund research, but manually pulling data for hundreds of funds is slow and repetitive. This scraper reads the public fund and ETF listings directly, letting you filter by asset type and category. You get a structured dataset without writing a single line of code.

| Who uses it | What they scrape Morningstar for |
|---|---|
| Financial advisors | Building a shortlist of top-rated funds in a specific category for client portfolios. |
| Individual investors | Comparing expense ratios and performance across all funds in a category. |
| Data analysts | Feeding a fund screening model with up-to-date Morningstar metrics. |
| Fintech product teams | Populating an investment product database with standardized fund data. |

### What it does

This Actor collects US mutual fund and ETF records from Morningstar, filtered by asset type and optional category, and returns each one as a flat row.

- 📊 **Asset type selection:** target US Mutual Funds or US ETFs with one dropdown.
- 🏷️ **Category filter:** narrow results to a specific Morningstar category like 'Large Blend' or 'Technology'.
- 📈 **Scalable collection:** set a maximum from 1 to 1,000,000 records per run to match your research scope.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Morningstar data

**📋 Build a fund watchlist.**

An individual investor scrapes all Large Blend ETFs to compare expense ratios and star ratings before making an allocation decision.

**📊 Feed a screening model.**

A data analyst pulls the full universe of US mutual funds into a Python notebook to rank them by risk-adjusted return metrics.

**🔍 Monitor a category.**

A financial advisor runs the scraper weekly on the Technology category to spot funds with improving Morningstar ratings for client reviews.

**🗃️ Populate a product database.**

A fintech team collects all US ETF records to seed their investment product search with standardized Morningstar data.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key required** | Access public Morningstar fund data without registering an application or managing OAuth tokens. |
| **Fixed flat schema** | Every fund returns the same fields, so your CSV or spreadsheet is clean and ready for analysis. |
| **Category targeting** | Filter by recognized Morningstar categories to compare only peer funds. |

### How it compares

This Actor focuses on bulk collection of US mutual fund and ETF records by category, while other Morningstar scrapers target individual securities by ticker or URL.

| Feature | ParseForge | Morningstar Scraper (4 users) | Morningstar Scraper (2 users) |
|---|---|---|---|
| Bulk fund collection by category | Yes, filter by Morningstar category name | Not listed | Not listed |
| US mutual fund universe | Yes | Yes | Not listed |
| US ETF universe | Yes | Yes | Yes |
| Scrape by ticker symbol | Not listed | Yes | Yes |
| Scrape by direct URL | Not listed | Yes | Not listed |
| Individual stock data | Not listed | Yes | Yes |

### Configure the run

Drive the Actor by selecting an asset type and an optional Morningstar category, and set a record limit so only the funds you need reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Morningstar Fund & ETF Scraper](https://apify.com/parseforge/morningstar-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Morningstar through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/morningstar-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your category filter spelling. It must match a Morningstar category name exactly, such as 'Large Blend'. Try leaving the category field blank to confirm results exist for the selected asset type.

**The run finished but returned fewer records than my maxItems setting.**

The Actor stops when it has collected all available funds matching your filters. If Morningstar lists fewer funds in that category than your maxItems value, you will receive all of them.

**Some fields are empty in my output.**

Morningstar does not populate every field for every fund. If a metric is not reported by the fund or not tracked by Morningstar, that cell will be blank in your dataset.

**The scraper is timing out or running slowly.**

Try reducing the maxItems value. Large runs with hundreds of thousands of records take more time. You can also split your work into multiple smaller runs by category.

**Can I scrape a specific fund by ticker?**

This Actor does not accept ticker symbols as input. It collects funds by asset type and category. Use the category filter to narrow results to the peer group containing your target fund.

### FAQ

| Question | Answer |
|---|---|
| Does this scraper require a Morningstar login or API key? | No. It reads the public fund and ETF listings from Morningstar's website. You do not need an account, an API key, or any OAuth setup. |
| What data fields does the scraper return? | The Actor returns a flat row per fund with the fields available on Morningstar's public listing pages. The exact fields are shown in the sample output on the Actor's page after a test run. |
| Can I scrape both mutual funds and ETFs in one run? | No. The asset type selector lets you choose either US Mutual Funds or US ETFs per run. Run the Actor twice with different settings to collect both. |
| How do I filter by a specific fund category? | Enter the exact Morningstar category name in the Category Filter field, such as 'Large Blend' or 'Technology'. Leave it blank to return all categories for the selected asset type. |
| Can I scrape individual stock data with this Actor? | This Actor is built for US mutual funds and US ETFs. It does not scrape individual stock quotes or company profiles. |
| How many records can I collect? | You can set the maximum from 1 up to 1,000,000 records per run. The actual number returned depends on how many funds match your asset type and category filters. |
| What export formats are supported? | Your dataset can be exported to CSV, JSON, Excel, or XML from the Apify platform. |
| Is the data real-time or delayed? | The scraper collects the data as it appears on Morningstar's public pages at the time of the run. Morningstar may update fund data daily or monthly depending on the metric. |
| Can I schedule this scraper to run automatically? | Yes. Apify supports scheduled runs. You can set this Actor to run daily, weekly, or on any custom cron schedule. |
| Does this work for non-US funds? | The current input schema supports US Mutual Funds and US ETFs. Non-US fund universes are not available in this Actor. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Morningstar, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many records to collect per run.

## `universeId` (type: `string`):

Filter by asset type: US mutual funds or US ETFs.

## `category` (type: `string`):

Optional Morningstar category name to filter results (e.g. 'Large Blend', 'Technology'). Leave blank for all categories.

## Actor input object example

```json
{
  "maxItems": 10,
  "universeId": "FOUSA"
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/morningstar-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/morningstar-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 '{
  "maxItems": 10
}' |
apify call parseforge/morningstar-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/morningstar-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/GqtSEpkADgdwNljJ7/builds/TiICE6zQNRMHPEcwB/openapi.json