# Niche Scholarships Scraper (`parseforge/niche-scholarships-scraper`) Actor

Scrapes Niche scholarship listings with award amounts, deadlines, eligibility text, and direct apply links. Returns each scholarship as a flat row ready for spreadsheets and databases.

- **URL**: https://apify.com/parseforge/niche-scholarships-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.62 / 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)

### Niche Scholarships Scraper

**Scrape Niche scholarships with award amounts, deadlines, eligibility, and direct application links.** Every scholarship comes with its dollar value, grade-level requirements, and the full description text. No login or API key. Export to CSV, JSON, Excel, or XML.

Niche lists thousands of scholarships but no official API or bulk export exists, so students and counselors spend hours clicking through pages one by one. This Actor reads the public scholarship directory directly, collects every listing that matches your target URL, and returns them in a flat, analysis-ready table. You get the dollar amount, deadline, eligibility text, and the direct link to apply, all in one run.

| Who uses it | What they scrape Niche for |
|---|---|
| High school counselors | Build a complete, filterable list of scholarships their students are eligible for this month. |
| College financial aid offices | Curate external scholarship opportunities to share with admitted and current students. |
| Scholarship platform operators | Aggregate fresh listings to power a searchable scholarship database. |
| Education nonprofits | Identify funding gaps and partner scholarships for underserved student populations. |

### What it does

This Actor collects Niche scholarship listings from a given directory page and returns each one as a flat row with its title, award amount, deadline, eligibility, and description.

- 💰 **Award amounts parsed:** dollar value extracted from the listing so you can sort by largest award.
- 📅 **Deadline captured:** application due date included when Niche displays it on the listing card.
- 🎓 **Eligibility text:** grade-level and other requirements pulled from the scholarship description.
- 🔗 **Direct apply link:** the URL that sends a student straight to the provider's application page.
- 📄 **Full description:** the body text Niche shows for each scholarship, preserved in one field.

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

### What you can do with Niche data

**📋 Build a scholarship bulletin.**

A high school counselor runs the Actor on the main Niche scholarships page each week, exports the CSV, and posts the newest awards on the school portal.

**🎯 Filter by eligibility.**

A nonprofit loads all scholarships, then filters the dataset in Excel by grade level and award amount to match their cohort of first-generation students.

**📊 Compare award sizes.**

A financial aid office scrapes the full directory, sorts by dollar value, and identifies the largest external scholarships to promote to admitted students.

**🔍 Power a search tool.**

A scholarship platform runs the Actor daily, ingests the fresh listings into their database, and lets students search by deadline and amount.

### Why choose this scraper

| | What you get |
|---|---|
| **No API needed** | Reads the public Niche directory so you skip app registration and rate limits. |
| **One fixed schema** | Every scholarship lands in the same columns, ready for a spreadsheet or database. |
| **Deadline-aware** | Application due dates are captured when present, so you can sort by urgency. |
| **Direct links** | Each row includes the URL that takes a student to the real application. |

### How it compares

This Actor scrapes Niche scholarships directly. The competitor below scrapes education nonprofits from ProPublica, a different source, so the comparison highlights which data each one collects.

| Feature | ParseForge | Education Nonprofit Scraper (ProPublica) |
|---|---|---|
| Niche scholarship listings | Yes | Not listed |
| Scholarship award amounts | Yes | Not listed |
| Application deadlines | Yes | Not listed |
| Direct apply links | Yes | Not listed |
| Nonprofit IRS filing data | Not listed | Yes |

### Configure the run

Drive the Actor from any Niche scholarships listing URL, set a maximum number of items to collect, and only the matching scholarships reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "startUrl": "https://www.niche.com/colleges/scholarships/",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "startUrl": "https://www.niche.com/colleges/scholarships/",
 "maxItems": 200
}
```

### Pricing

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

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.40 |
| 1,000 results | $4.00 |
| 10,000 results | $40.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 [Niche Scholarships Scraper](https://apify.com/parseforge/niche-scholarships-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 Niche 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/niche-scholarships-scraper"
```

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

### Troubleshooting

**Why am I getting no results?**

Check that your start URL points to a valid Niche scholarships listing page. If the page has no scholarship cards, or if Niche changed its layout, the Actor may return nothing. Try the default URL first.

**The Actor stopped before reaching my max items limit.**

The Actor stops when there are no more scholarship listings to collect on the paginated path. If the directory has fewer items than your max, it finishes early.

**Some scholarships are missing the award amount or deadline.**

Niche does not always display every field on the listing card. The Actor captures only what is visible on the page. Missing fields will be empty in your dataset.

**I got blocked or the run failed.**

The Actor uses Apify's proxy infrastructure to avoid detection. If you still see blocks, try reducing your max items or adding a delay between runs.

**The application link does not work.**

The Actor captures the link exactly as Niche provides it. If the provider removed the page, the link may be broken. Verify the URL directly on Niche.

### FAQ

| Question | Answer |
|---|---|
| Does this Actor require a Niche login? | No. It reads the public scholarship directory pages, so no account, password, or API key is needed. |
| What data does each row contain? | Each row includes the scholarship title, award amount, deadline, eligibility text, description, and the direct application link, when those fields are present on the listing. |
| Can I scrape a specific category of scholarships? | Yes. Set the start URL to any filtered Niche scholarships page, such as scholarships for a particular major, state, or grade level, and the Actor collects only those listings. |
| How many scholarships can I scrape in one run? | Free users are limited to 10 items as a preview. Paid users can set a maximum up to 1,000,000 items per run. |
| Does the Actor follow pagination? | Yes. It starts at the URL you provide and walks through all subsequent pages until it hits your max items limit or runs out of listings. |
| Will I get duplicate scholarships? | The Actor collects each listing as it appears on the page. If Niche shows the same scholarship on multiple pages, it will appear multiple times in your dataset. |
| Can I get the scholarship provider's name? | The provider name is included in the description or title field when Niche displays it on the listing card. |
| What export formats are supported? | You can export your results to CSV, JSON, Excel, or XML directly from the Apify dataset. |
| Does this Actor work for Niche college reviews or rankings? | No. This Actor is built for the scholarships directory. For college data, use a dedicated Niche college scraper. |
| How often should I run this Actor? | Scholarship listings change as deadlines pass and new awards are added. Running it weekly keeps your dataset current. |
| Is the award amount always a number? | The Actor captures the amount as Niche displays it. Some listings show a range or a text description, which is preserved as-is. |

### 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 Niche.com, 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

## `startUrl` (type: `string`):

The URL of the Niche scholarships listing page to scrape. Defaults to the main scholarships page.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "startUrl": "https://www.niche.com/colleges/scholarships/",
  "maxItems": 10
}
```

# Actor output Schema

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

Complete dataset of all scraped records.

# 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 = {
    "startUrl": "https://www.niche.com/colleges/scholarships/",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/niche-scholarships-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 = {
    "startUrl": "https://www.niche.com/colleges/scholarships/",
    "maxItems": 10,
}

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

```

## MCP server setup

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