# College Scorecard Scraper (`parseforge/college-scorecard-scraper`) Actor

Scrape 6,000+ US colleges and universities from College Scorecard. Get tuition costs, admission rates, graduation rates, post-graduation earnings, demographics, financial aid data, and 65+ fields per school. Filter by state and degree type.

- **URL**: https://apify.com/parseforge/college-scorecard-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🎓 College Scorecard Scraper

Whether you're a student comparing universities, a researcher analyzing higher education trends, or a consultant building college recommendation tools, this scraper delivers comprehensive data from the U.S. Department of Education's College Scorecard.

> **The College Scorecard Scraper collects data on 6,000+ U.S. colleges and universities including tuition costs, admission rates, graduation rates, post-graduation earnings, demographics, financial aid, and institutional details. Filter by state and degree type.**

### ✨ What Does It Do

- 🏫 **School profiles** - collect names, locations, accreditors, ownership type, and degree levels for thousands of institutions
- 💰 **Cost data** - extract in-state and out-of-state tuition, average net price, cost of attendance, room and board
- 📊 **Outcomes** - get admission rates, completion rates, retention rates, SAT/ACT scores
- 💵 **Earnings and debt** - median earnings at 6 and 10 years after enrollment, median debt, monthly loan payments
- 👥 **Demographics** - student body size, gender breakdown, racial/ethnic composition, first-generation students
- 🏛️ **Institutional data** - faculty salary, student-faculty ratio, endowment, instructional expenditure per student

### 🔧 Input

- **Max Items** - how many schools to collect (free users get 10 items, paid users up to 1,000,000)
- **State** - two-letter US state abbreviation to filter results (e.g., CA, TX, NY)
- **Degree Type** - filter by predominant degree: Certificate, Associate, Bachelor's, or Graduate

```json
{
    "maxItems": 100,
    "state": "CA",
    "degreeType": "bachelor"
}
````

### 📊 Output

Each school record includes 65+ data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| name | Institution name |
| city, state, zip | Location |
| url | School website |
| ownership | Public, Private nonprofit, or Private for-profit |
| admissionRate | Overall admission rate |
| inStateTuition | In-state tuition |
| outOfStateTuition | Out-of-state tuition |
| avgNetPrice | Average net price after aid |
| studentSize | Total undergraduate enrollment |
| completionRate | Overall completion rate |
| retentionRate | First-year retention rate |
| medianEarnings10Years | Median earnings 10 years after enrollment |
| medianDebt | Median student debt at completion |
| satAverageScore | Average SAT score |
| studentFacultyRatio | Student to faculty ratio |
| pellGrantRate | Percentage receiving Pell grants |

```json
{
    "id": 110635,
    "name": "University of California-Berkeley",
    "city": "Berkeley",
    "state": "CA",
    "zip": "94720",
    "url": "www.berkeley.edu",
    "ownership": "Public",
    "admissionRate": 0.1139,
    "satAverageScore": 1415,
    "inStateTuition": 14312,
    "outOfStateTuition": 44066,
    "avgNetPrice": 17830,
    "studentSize": 32143,
    "completionRate": 0.9333,
    "medianEarnings10Years": 85800,
    "medianDebt": 14764,
    "studentFacultyRatio": 20,
    "pellGrantRate": 0.3036,
    "latitude": 37.871899,
    "longitude": -122.258538,
    "scrapedAt": "2026-04-08T12:00:00.000Z"
}
```

### 💎 Why Choose the College Scorecard Scraper?

| Feature | Our Tool | Manual College Scorecard |
|---------|----------|------------------------|
| Batch collection | ✅ Up to 1M schools | ❌ Browse one at a time |
| Data fields | ✅ 65+ fields per school | ⚠️ Limited comparison view |
| Structured output | ✅ JSON, CSV, Excel | ❌ HTML pages only |
| Automated scheduling | ✅ Daily/weekly updates | ❌ Manual visits |
| Filter and sort | ✅ State + degree type | ⚠️ Basic search |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your state, degree type, and how many schools you want
3. **Run It** - click "Start" and get structured college data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🎓 **Students and parents** - compare schools by cost, admission rate, graduation rate, and post-graduation earnings
- 📊 **Researchers** - analyze trends in higher education costs, enrollment, and outcomes across states
- 🏢 **EdTech companies** - build college comparison tools and recommendation engines with real federal data
- 📈 **Financial advisors** - assess school ROI by comparing tuition costs against median earnings
- 🏛️ **Policy analysts** - track institutional performance metrics across public and private universities
- 💼 **Recruiters** - identify top-performing schools by field of study and post-graduation employment

### ❓ FAQ

🎓 **What is the College Scorecard?**
The College Scorecard is a U.S. Department of Education tool that provides data on over 6,000 colleges and universities, including costs, graduation rates, and post-graduation earnings.

🔍 **What state codes can I use?**
Standard two-letter US state abbreviations: CA, TX, NY, FL, IL, PA, OH, GA, NC, MI, etc.

📊 **What degree types are available?**
Certificate, Associate, Bachelor's, and Graduate. This filters by the school's predominant degree awarded.

⏱️ **How long does a run take?**
About 1-3 seconds per 100 schools. A full US dataset of 6,000+ schools takes under a minute.

### 🔗 Integrate College Scorecard Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate education data workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Sync school data to your tools
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified when data is ready
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more education and government data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Grants.gov Scraper | Collect federal grant opportunities | [Link](https://apify.com/parseforge/grants-gov-scraper) |
| Greatschools Scraper | Extract K-12 school ratings and reviews | [Link](https://apify.com/parseforge/greatschools-scraper) |
| BLS Wage Data Scraper | Get employment and wage statistics | [Link](https://apify.com/parseforge/bls-wage-data-scraper) |
| FMCSA Carrier Safety Scraper | Look up trucking company safety data | [Link](https://apify.com/parseforge/fmcsa-carrier-safety-scraper) |
| Federal Register Scraper | Collect regulatory notices and rules | [Link](https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the U.S. Department of Education or the College Scorecard. It accesses only publicly available data through official public APIs.

# Actor input Schema

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

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

## `state` (type: `string`):

Two-letter US state abbreviation to filter results (e.g. CA, TX, NY). Leave empty for all states.

## `degreeType` (type: `string`):

Filter by predominant degree type offered

## Actor input object example

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

# Actor output Schema

## `schools` (type: `string`):

Complete dataset with all scraped school records

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

Overview of schools with key fields

# 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/college-scorecard-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/college-scorecard-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 '{
  "maxItems": 10
}' |
apify call parseforge/college-scorecard-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "College Scorecard Scraper",
        "description": "Scrape 6,000+ US colleges and universities from College Scorecard. Get tuition costs, admission rates, graduation rates, post-graduation earnings, demographics, financial aid data, and 65+ fields per school. Filter by state and degree type.",
        "version": "0.0",
        "x-build-id": "d7dFbumnLcCesDF34"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~college-scorecard-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-college-scorecard-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/parseforge~college-scorecard-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-college-scorecard-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/parseforge~college-scorecard-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-college-scorecard-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Two-letter US state abbreviation to filter results (e.g. CA, TX, NY). Leave empty for all states."
                    },
                    "degreeType": {
                        "title": "Degree Type",
                        "enum": [
                            "certificate",
                            "associate",
                            "bachelor",
                            "graduate"
                        ],
                        "type": "string",
                        "description": "Filter by predominant degree type offered"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
