Snapshot DAO Governance Scraper: $5.00 per 1,000 results (2026)

Over the last 30 days this Actor recorded 30 public runs with a 100.0% success rate across 74 total runs. Scrape Snapshot.org DAO governance data including proposals, spaces, and votes for tens of thousands of decentralized organizations using the public hub.snapshot.org/graphql API. No login, no API key, and no cookies are required to query voting hubs. Results return proposal metadata, choice arrays, and timestamps with empty fields omitted. This tool is built for data engineers, governance analysts, and protocol researchers.

What does a Snapshot DAO Governance Scraper run cost?

Each result costs $0.005 on the free tier, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.01 per GB of Actor memory.

Apify plan	Per result	Per 1,000 results
FREE	$0.005	$5.00
BRONZE	$0.00433	$4.33
SILVER	$0.00367	$3.67
GOLD	$0.003	$3.00
PLATINUM	$0.003	$3.00
DIAMOND	$0.003	$3.00

Each result costs 0.005 USD, which equals 5.00 USD per 1,000 results on the free tier. Adjusting the maxItems control is the most direct way to cap result volume and control expenses during initial testing. Run a small test with a low item limit to verify output structure before executing large extractions.

How do you run Snapshot DAO Governance Scraper from the API?

The schema marks 1 of its 21 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Snapshot DAO Governance Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~snapshot-dao-governance-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"proposals","space":"ens.eth","state":"","proposalType":"","proposalOrderBy":"created","proposalIds":[],"searchText":"uniswap","verifiedOnly":false,"spaceOrderBy":"created","spaceIds":[],"voteOrderBy":"created","orderDirection":"desc","maxItems":25,"proxyConfiguration":{"useApifyProxy":true}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "proposals",
  "space": "ens.eth",
  "state": "",
  "proposalType": "",
  "proposalOrderBy": "created",
  "proposalIds": [],
  "searchText": "uniswap",
  "verifiedOnly": False,
  "spaceOrderBy": "created",
  "spaceIds": [],
  "voteOrderBy": "created",
  "orderDirection": "desc",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": True
  }
}

run = client.actor("crawlerbros~snapshot-dao-governance-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "proposals",
  "space": "ens.eth",
  "state": "",
  "proposalType": "",
  "proposalOrderBy": "created",
  "proposalIds": [],
  "searchText": "uniswap",
  "verifiedOnly": false,
  "spaceOrderBy": "created",
  "spaceIds": [],
  "voteOrderBy": "created",
  "orderDirection": "desc",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

const run = await client.actor('crawlerbros~snapshot-dao-governance-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Snapshot DAO Governance Scraper inputs matter, and which can you skip?

The mode control determines what data the Actor fetches, switching between proposals, space profiles, and individual votes. Most first-time runs should leave optional filters like authorAddress and minVotingPower blank to ensure broad initial coverage.

mode (string): What to fetch. Default: "proposals".
space (string): Filter proposals to a single space, e.g. ens.eth, aavedao.eth, uniswapgovernance.eth. Also narrows mode=votesByVoter.
state (string): Filter by voting state. Default: "".
titleContains (string): Case-insensitive substring match on the proposal title.
network (string): Filter by blockchain network ID, e.g. 1 (Ethereum), 137 (Polygon), 42161 (Arbitrum), 8453 (Base), 10 (Optimism), 56 (BNB Chain), 100 (Gnosis).
authorAddress (string): Only return proposals created by this 0x wallet address. Confirmed honored server-side by Snapshot's own API.
proposalType (string): Filter by the proposal's voting system. Confirmed honored server-side by Snapshot's own API. Default: "".
minVotes (integer): Only include proposals with at least this many votes cast.
proposalOrderBy (string): Sort field for proposal results (mode=proposals). Note: scores_total_value is not reliably honored by Snapshot's own API (confirmed via direct testing -- it silently falls back to created-date order); created, votes, start, and end all sort correctly. Default: "created".
proposalIds (array): Snapshot proposal IDs (0x-prefixed hashes). Default: [].
searchText (string): Full-text search against space name/ENS domain.
verifiedOnly (boolean): Only emit spaces Snapshot has marked as verified. Default: false.
spaceOrderBy (string): Sort field for space results (mode=spaces). Note: followersCount/proposalsCount/votesCount are NOT reliably honored by Snapshot's own API (confirmed via direct testing -- it silently falls back to created-date order for these three); only created reliably sorts server-side. Results are still complete/correct either way, just not necessarily in the requested order for the three unreliable fields. Default: "created".
spaceIds (array): Snapshot space IDs (ENS names), e.g. ens.eth. Default: [].
voteProposalId (string): Fetch every vote cast on this proposal.
voterAddress (string): 0x wallet address. Returns this voter's cast votes, optionally narrowed with space.
minVotingPower (number): Only include votes with at least this much voting power.
voteOrderBy (string): Sort field for vote results (modes=votes/votesByVoter). Default: "created".
orderDirection (string): Sort direction applied to the chosen order-by field. Default: "desc".
maxItems (integer): Hard cap on emitted records. Default: 25.
proxyConfiguration (object): Optional. Snapshot's public GraphQL API is not blocked from Apify's datacenter IPs; this is only used as an automatic fallback if it starts returning 403/429 responses. Default: {"useApifyProxy":true}.

Fixed-choice controls: mode accepts proposals, proposalByIds, spaces, spaceByIds, votes, votesByVoter; state accepts , `pending`, `active`, `closed`; `proposalType` accepts , single-choice, approval, quadratic, ranked-choice, weighted; proposalOrderBy accepts created, votes, scores_total_value, start, end; spaceOrderBy accepts followersCount, proposalsCount, votesCount, created; voteOrderBy accepts created, vp; orderDirection accepts desc, asc.

Move one control per run. Compare each new sample against the previous one and keep the accepted, uncertain, and excluded counts side by side. A control that increases volume without improving decision quality still bills at $0.005 per result.

What does Snapshot DAO Governance Scraper return?

Returned records provide proposal metadata, space profiles, and vote details including choice arrays and timestamps. They supply structured data suitable for governance analytics dashboards and DAO research without requiring authentication.

The Actor does not publish a per-field output list, so treat the first run as the specification: collect a small sample and record which fields are present before anything downstream depends on them.

How do you build the workflow end to end?

Open Snapshot DAO Governance Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Set the mode control to proposals to begin retrieving DAO voting items from Snapshot.org.
Define the space parameter with a specific ENS name such as ens.eth to filter items to a single DAO.
Adjust the state parameter to active if you want to inspect ongoing voting procedures.
Configure the maxItems control to 25 to establish a hard cap on emitted records for your initial test.
Leave optional filters such as authorAddress and proposalType blank on your first execution to verify baseline connectivity.
Execute the run and examine the emitted recordType and scrapedAt fields to confirm schema validity.
Inspect the resulting proposal records for populated choice and score arrays before scaling up your collection volume.

How do you apply it? Three worked playbooks

These are Snapshot DAO Governance Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Governance dashboards

Outcome: track proposal activity and outcomes across one or many DAOs

Configure: Set mode to proposals, space to ens.eth, and maxItems to 20.

Working method: Execute the run with space filtering enabled for a prominent DAO, inspect the returned proposal titles and states, and compare active proposal counts against historical averages to establish a baseline.

Deliverable: A structured dataset of proposal records containing identifiers, states, and score totals across the designated DAO.

Stop condition: The run emits zero proposal records or fails to return valid space identifiers for the specified ENS name.

Use case 2: DAO research

Outcome: compare voter participation, quorum, and voting-power concentration

Configure: Set mode to votes, voteProposalId to a valid 0x proposal hash, and maxItems to 50.

Working method: Target a specific proposal hash, examine the retrieved vote records for voting power distribution, and cross-reference individual voter addresses with participation thresholds.

Deliverable: A collection of vote records detailing voter addresses, choice selections, and calculated voting power for the selected proposal.

Stop condition: The proposal ID returns an empty vote list despite confirmed on-chain participation.

Use case 3: Delegate/voter analytics

Outcome: audit a wallet's full cross-DAO voting history

Configure: Set mode to votesByVoter, voterAddress to a target 0x wallet address, and maxItems to 50.

Working method: Input the specific wallet hash, review the chronological voting history returned by the endpoint, and check whether voting power metrics align with expected token balances.

Deliverable: An audit trail of vote records cast across multiple DAOs by the specified wallet address.

Stop condition: The voter address returns no historical vote records or encounters unhandled pagination errors.

What breaks, and how do you design around it?

Test a small, representative input against your acceptance criteria before increasing scope.

Upstream sorting behavior for specific aggregate fields like followersCount and scores_total_value silently defaults to creation date order on Snapshot's backend. When these specific sort orders are required, fetch the complete dataset and sort the records locally in your processing pipeline.

When should you not use Snapshot DAO Governance Scraper?

Do not use this Actor if your project requires direct access to off-chain forum discussions or IPFS storage contents beyond basic body text. If you only need to inspect a single static proposal or query a single DAO without pagination, writing a direct HTTP request to the public GraphQL endpoint without an Actor may avoid platform overhead. This Actor is also unsuited for tasks requiring real-time websocket monitoring of unfinalized mempool transactions, as Snapshot indexes data after submission. If your workflow depends on qualitative debate logs rather than structured vote tallies and proposal metadata, this tool will not capture the required data.

What should you check before trusting the output?

Verify that proposal records contain non-empty choice and score arrays corresponding to voting options.
Check that space records successfully emit verified boolean flags and associated member counts.
Confirm that vote records include valid votingPower numerical values rather than null or malformed data.
Ensure that empty fields are omitted from the returned JSON structures as specified by the endpoint.
Stop any scheduled extraction immediately if the output records return empty payloads or missing identifier fields.

None of this proves a record is correct. It gives a scheduled Snapshot DAO Governance Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Do I need a Snapshot or wallet account to run this scraper?

No. Every endpoint used here is Snapshot's public, unauthenticated GraphQL API at hub.snapshot.org/graphql. No login, no API key, no cookies are required to fetch complete proposal and vote datasets.

How are costs calculated for running this Actor on Apify?

Each result costs 0.005 USD, which totals 5.00 USD per 1,000 results on the free tier. Higher subscription tiers reduce the per-result cost down to 3.00 USD per 1,000 results on plan levels like gold, platinum, and diamond.

Why do certain sorting controls fail to order records correctly?

When requested, the upstream API silently falls back to creation date sorting for specific aggregate fields like followersCount, proposalsCount, votesCount, and scores_total_value. Every record returned is still complete and correct, but you may need to sort them locally if those specific orders are required.

What does votingPower represent on a returned vote record?

It represents the voter's token or strategy-weighted voting power at the proposal's snapshot block. It is not a simple 1-address-1-vote count.

How can I retrieve votes cast by a specific wallet address?

Set the mode control to votesByVoter and supply the target wallet address to the voterAddress input field. You can optionally narrow the query by providing a specific space ENS name to filter results.

Where to go next

Start with the Snapshot DAO Governance Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

Profile scrapers covers 115 Actors in this family.

Readers running Snapshot DAO Governance Scraper commonly pair it with:

Instagram Transcript Scraper Extract transcripts from Instagram videos and reels using auto-generated captions or AI-powered speech-to-text.
Wellfound (AngelList) Jobs Scraper Scrape public job listings from Wellfound.com.
Etsy Scraper Scrape product listings from Etsy search results, categories, shops, and product pages.
Website Screenshot Generator Capture full-page screenshots of any website as PNG images or PDF documents.
Google News Scraper Scrape Google News in real-time.
Quora Search Scraper Search Quora by keywords and extract questions, answers, author info, upvotes, and engagement metrics.
ZipRecruiter Jobs Scraper Pro Extract job postings from ZipRecruiter.com with FULL job descriptions.
Resident Advisor (RA) Scraper Scrape Resident Advisor (ra.co) with upcoming events by city, artist profiles, and venue/club profiles.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-22.
Actor last updated by its maintainers on 2026-07-11.
Run outcome figures cover the 30 day public window ending 2026-09-22.
Snapshot DAO Governance Scraper on Apify