# Galxe Quest & Airdrop Rewards Scraper (`tactful_anvil/galxe-quest-rewards-scraper`) Actor

Scrape Galxe's live quest board (9,000+ campaigns): token rewards in human units, stablecoin rewards in USD, slots vs participants (fill ratio), FCFS vs raffle, verified-space flag and a 0-100 opportunity score. Find under-subscribed paid quests early. HTTP-only, no login, no key.

- **URL**: https://apify.com/tactful\_anvil/galxe-quest-rewards-scraper.md
- **Developed by:** [Mr Zack](https://apify.com/tactful_anvil) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 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.

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.

- **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

## Galxe Quest & Airdrop Rewards Scraper

Scrape **Galxe's entire live quest board** — 9,000+ active campaigns — into one clean dataset: **token rewards in human units, stablecoin rewards in USD, slots vs participants, FCFS/raffle type, verified-space flag and a 0–100 opportunity score** per quest. Plain HTTPS, no login, no API key, no proxy.

Galxe is the largest onchain quest platform. Projects fund quests with USDT/USDC pools, token drops, points and roles — and the board moves every hour. Farmers who spot a fresh **$50-per-user USDC quest with 10 slots** before the crowd win; everyone refreshing the website manually loses.

### Who is this for

- **Airdrop farmers & quest hunters** — rank every live quest by real reward per user, skip the brutal ones (6,700 wallets fighting 10 slots), catch fresh FCFS pools while `fillRatio < 1`.
- **Alpha groups & Telegram/Discord bots** — pipe the dataset into your feed; `closingWithin48h` + `rewardPerUserUsd` is a ready-made alert.
- **Web3 growth & BD teams** — see what reward sizes, chains and mechanics competitors use for quests that actually pull participants.
- **Researchers** — the only structured feed of Galxe reward economics: pool sizes, fill rates, chain distribution.

### What you get per quest

| Field | Meaning |
| --- | --- |
| `name`, `url`, `status`, `chain` | The quest itself, deep-linked (`app.galxe.com/quest/...`) |
| `rewardPerUserToken`, `token` | Token amount per user in **human units** (decimals applied — no wei noise) |
| `rewardPerUserUsd` | Stablecoins (USDT/USDC/DAI/...) converted 1:1. Volatile tokens stay `null` — honest, never guessed |
| `totalPoolUsd` | Per-user USD × slots |
| `slots`, `participants`, `fillRatio` | Reward cap vs wallets already in. `fillRatio > 1` on FCFS = you're late |
| `competition` | `none` / `low` / `medium` / `high` / `brutal` |
| `distributionType` | `FCFS` or `RAFFLE` — changes your strategy completely |
| `endsInDays`, `closingWithin48h` | Deadline math done for you |
| `spaceVerified`, `spaceFollowers` | Trust signal on the project running the quest |
| `requireEmail`, `geoBlocked` | Friction flags before you click |
| `opportunityScore` | 0–100: reward (40) + space trust (20) + competition (25) + urgency (15) |

### How to run it on a schedule (recommended)

The board changes hourly — one-off runs go stale fast. In Apify Console:

1. Open **Schedules → Create new**, pick this Actor.
2. Cron `0 */6 * * *` (every 6 hours) is the sweet spot for FCFS hunting; daily works for research.
3. Set input once, e.g. `{"stableRewardOnly": true, "maxFillRatio": 1, "sortBy": "opportunity"}` — every run then delivers only under-subscribed quests that pay real USD.
4. Add an integration (webhook, Make, Zapier, Google Sheets) to push fresh rows wherever you work.

A 1,000-row run costs about **$1.21** and takes ~30 seconds.

### Example input

```json
{
  "statuses": ["Active"],
  "stableRewardOnly": true,
  "maxFillRatio": 2,
  "excludeEmailGated": true,
  "sortBy": "opportunity",
  "maxItems": 1000
}
```

### FAQ

**Does it need my Galxe account?** No. Public data only, rate-limited politely.

**Why is `rewardPerUserUsd` null on some token quests?** Non-stablecoin rewards aren't price-guessed. You still get the exact token amount and symbol.

**Can I filter server-side?** Yes — `searchText` (e.g. `"USDT"`) and `chains` (e.g. `["BASE","SOLANA"]`) filter before billing.

### Related Actors by the same author

- [HackenProof Bug Bounty & Audit Scraper](https://apify.com/tactful_anvil/hackenproof-bug-bounty-scraper) — bounty programs with **proven payout totals**
- [Immunefi Bug Bounty Scraper](https://apify.com/tactful_anvil/immunefi-bug-bounty-audit-competition-scraper) — web3's biggest bounty board
- [Merkl DeFi Rewards Scraper](https://apify.com/tactful_anvil/merkl-defi-rewards-scraper) — live DeFi incentive campaigns with APR
- [Superteam Earn Scraper](https://apify.com/tactful_anvil/superteam-earn-scraper) — Solana bounties with EV per entry
- [Whop Content Rewards Scraper](https://apify.com/tactful_anvil/whop-content-rewards-scraper) — clipping campaign board

***

Found this useful? **A rating on the Reviews tab genuinely helps** other quest hunters find it. Found a bug or missing field? Open an Issue — I ship fixes fast.

# Actor input Schema

## `statuses` (type: `array`):

Which campaign statuses to pull. Default: Active only.

## `searchText` (type: `string`):

Optional server-side search over quest names (e.g. "USDT", "airdrop", a project name).

## `chains` (type: `array`):

Optional chain filter, e.g. ETHEREUM, BSC, BASE, ARBITRUM, SOLANA. Empty = all chains.

## `tokenRewardOnly` (type: `boolean`):

Keep only quests that pay a real token amount per user (drops Discord-role / points-only quests).

## `stableRewardOnly` (type: `boolean`):

Keep only quests whose per-user reward is a stablecoin (USDT, USDC, DAI, ...) — i.e. rows with a real USD value.

## `verifiedSpacesOnly` (type: `boolean`):

Keep only quests from Galxe-verified project spaces.

## `excludeEmailGated` (type: `boolean`):

Drop quests that require handing over an email address.

## `minRewardPerUserUsd` (type: `integer`):

Keep only stable-reward quests paying at least this much per user.

## `maxFillRatio` (type: `integer`):

Drop capped quests already contested beyond this ratio (participants / slots). 1 = drop anything oversubscribed.

## `minOpportunityScore` (type: `integer`):

0-100 floor on the derived opportunity score.

## `sortBy` (type: `string`):

Row order in the dataset.

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

Hard cap on campaigns fetched (each pushed row is billed). Board has ~9,000 active quests; 1,000 newest is plenty for a daily radar.

## `pageDelayMs` (type: `integer`):

Politeness delay between GraphQL pages.

## Actor input object example

```json
{
  "statuses": [
    "Active"
  ],
  "chains": [],
  "tokenRewardOnly": false,
  "stableRewardOnly": false,
  "verifiedSpacesOnly": false,
  "excludeEmailGated": false,
  "sortBy": "opportunity",
  "maxItems": 1000,
  "pageDelayMs": 700
}
```

# Actor output Schema

## `quests` (type: `string`):

One row per Galxe quest: token reward per user, stablecoin USD value, slots vs participants (fill ratio), FCFS/raffle type, deadline math and 0-100 opportunity score.

# 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 = {
    "statuses": [
        "Active"
    ],
    "searchText": "",
    "chains": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("tactful_anvil/galxe-quest-rewards-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 = {
    "statuses": ["Active"],
    "searchText": "",
    "chains": [],
}

# Run the Actor and wait for it to finish
run = client.actor("tactful_anvil/galxe-quest-rewards-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 '{
  "statuses": [
    "Active"
  ],
  "searchText": "",
  "chains": []
}' |
apify call tactful_anvil/galxe-quest-rewards-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tactful_anvil/galxe-quest-rewards-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/PZXnp1wTFOUnZZd1N/builds/21qAWWNiTHdLKTMB7/openapi.json