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

Over the last 30 days this Actor recorded 30 public runs with zero failures or timeouts, delivering clean governance payloads directly from tally.xyz without requiring an API key or wallet connection. This tool extracts DAO metadata, proposal statuses, full markdown descriptions, voting quorums, and top delegate rosters for over 1,700 decentralized organizations. Empty fields are omitted entirely from every payload to ensure downstream parsers receive only verified values. This Actor is built for data engineers, protocol researchers, and DAO operators who need structured governance intelligence, and it is not intended for high-frequency on-chain transaction execution or real-time mempool sniffing.

What does a Tally (Cactus) 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, which scales to $5.00 per 1,000 results on the free tier. Adjusting the maxItems parameter is the most effective way to control your billing exposure during exploratory runs before executing larger extractions.

How do you run Tally (Cactus) DAO Governance Scraper from the API?

The schema marks 1 of its 7 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

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~tally-dao-governance-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"daos","daoSlugs":[],"daoSlug":"uniswap","statusFilter":"any","proposalIds":["93"],"maxItems":20,"proxyConfiguration":{"useApifyProxy":false}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "daos",
  "daoSlugs": [],
  "daoSlug": "uniswap",
  "statusFilter": "any",
  "proposalIds": [
    "93"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": False
  }
}

run = client.actor("crawlerbros~tally-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": "daos",
  "daoSlugs": [],
  "daoSlug": "uniswap",
  "statusFilter": "any",
  "proposalIds": [
    "93"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

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

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Tally (Cactus) DAO Governance Scraper inputs matter, and which can you skip?

The input schema exposes 7 controls with only mode required for execution. Most users should rely on default values for proxyConfiguration on an initial run while explicitly defining daoSlug and mode to match their targets.

mode (string): What to fetch. Default: "daos".
daoSlugs (array): Specific DAO slugs to look up (from a tally.xyz/gov/ URL), e.g. uniswap, ens, arbitrum. Leave empty to browse the current top DAOs by delegate count. Default: [].
daoSlug (string): The DAO slug from its tally.xyz/gov/ URL. Required for modes proposals, proposalDetail, delegates. Default: "uniswap".
statusFilter (string): Only return proposals in this state. any returns all recent proposals regardless of state. Default: "any".
proposalIds (array): On-chain proposal IDs (the number in a tally.xyz/gov//proposal/ URL) to fetch full detail for. Default: ["93"].
maxItems (integer): Hard cap on emitted records. Note: Tally's public pages expose only the most recent ~10 proposals and top ~20 delegates per DAO without an authenticated API key. Default: 20.
proxyConfiguration (object): Optional. Only used as an automatic fallback if tally.xyz starts returning 403/429 responses. Leave default for normal operation (no proxy cost). Default: {"useApifyProxy":false}.

Fixed-choice controls: mode accepts daos, proposals, proposalDetail, delegates; statusFilter accepts any, active, pending, succeeded, queued, executed.

Change a single control per run and diff the result against the last sample, sorting records into accepted, uncertain, and excluded. A control that increases volume without improving decision quality still bills at $0.005 per result.

What does Tally (Cactus) DAO Governance Scraper return?

Returned records provide structured governance data including proposal identifiers, voting breakdowns, treasury values, and delegate addresses. They conspicuously omit historical proposal pagination beyond the most recent entries and deep historical logs requiring authenticated API keys.

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 Tally (Cactus) 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.

Select daos, proposals, proposalDetail, or delegates in the mode parameter before executing your first test run.
Set daoSlug to uniswap or another target DAO when running proposals, proposalDetail, or delegates mode.
Populate daoSlugs with an array of specific strings such as uniswap, ens, or arbitrum if you are using mode set to daos.
Restrict statusFilter to active or succeeded instead of any if you need to isolate live governance activity.
Add specific numerical proposal identifiers to proposalIds when targeting mode set to proposalDetail.
Set maxItems to a small integer between 1 and 20 to verify the output structure before pulling larger sets.
Inspect the emitted records to confirm fields such as daoSlug, proposalId, or address are populated before scaling up your run.

How do you apply it? Three worked playbooks

These are Tally (Cactus) 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 status and outcomes across one or many DAOs

Configure: Set mode to proposals, daoSlug to ens, and statusFilter to active.

Working method: Execute a baseline pull for the target DAO, inspect the returned array for active proposal records, and cross-reference voting deadlines with current block timestamps.

Deliverable: A structured JSON dataset containing active ENS proposals, their descriptions, and current vote counts.

Stop condition: Zero records are returned despite known active proposals on the target governance page.

Use case 2: DAO research

Outcome: compare quorum, treasury value, and voter turnout between DAOs

Configure: Set mode to daos and leave daoSlugs empty to pull top platforms.

Working method: Run the initial browse query, extract treasury values and delegate counts for comparison, and verify token symbol consistency across entries.

Deliverable: A comparative dataset of top DAOs ranked by delegate count and treasury size.

Stop condition: The output records fail to include treasuryValueUsd or tokenSymbol fields.

Use case 3: Delegate discovery

Outcome: find and rank top delegates/voters by voting power for a DAO

Configure: Set mode to delegates and daoSlug to uniswap.

Working method: Retrieve the top delegates list, sort entries by voting power and delegator count, and examine ENS name resolution fields.

Deliverable: A ranked list of top delegates for the specified DAO including addresses and social profile links.

Stop condition: Returned delegate addresses are missing or votesCount values return as null.

What breaks, and how do you design around it?

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

Pagination depth is constrained by public frontend limits on tally.xyz, which expose only the most recent ~10 proposals and top ~20 delegates per DAO without an authenticated key. Bypass this limitation by querying specific proposal IDs directly via proposalDetail mode or passing explicit DAO slugs.

When should you not use Tally (Cactus) DAO Governance Scraper?

Do not use this Actor if you require complete historical archives spanning hundreds of past proposals or thousands of delegates per DAO, as public unauthenticated page limits will truncate deep history. For comprehensive historical governance analytics, query an official sub-graph indexer, connect directly to snapshot.org and on-chain governor smart contracts via RPC, or use an authenticated enterprise API key from Tally. Relying on this scraper for exhaustive multi-year governance audits across thousands of legacy proposals will result in incomplete datasets due to upstream platform rendering caps.

What should you check before trusting the output?

Verify that daoSlug is never empty or null across proposal and delegate records.
Confirm that proposalId is present and non-null for every item emitted in proposals mode.
Check that votesFor and quorum fields contain numeric floating-point strings rather than malformed strings or nulls.
Verify that address fields in delegates mode conform to standard Ethereum hexadecimal formatting.
Check that scrapedAt timestamps are present on all records and reflect recent collection dates.
Halt downstream ingestion if returned item counts drop unexpectedly to zero for a known active DAO.

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

Frequently asked questions

What is the cost per result on paid plans for the Tally DAO Governance Scraper?

On the free tier, each result costs $0.005, scaling to $5.00 per 1,000 results. Paid tiers such as Bronze, Silver, and Gold reduce this unit cost further down to $3.00 per 1,000 results on higher plans, making large-scale DAO aggregation cost-effective for recurring analytical pipelines.

Does this Actor require an API key or crypto wallet to scrape tally.xyz data?

No wallet connection, authentication cookie, or API key is required. The Actor extracts publicly accessible governance data directly from tally.xyz pages, allowing you to run extractions without managing credentials or provisioning rate-limited developer accounts.

Why does proposals mode return only a limited subset of recent proposals?

Tally's public unauthenticated web interface renders only the most recent ~10 proposals per DAO. To fetch older proposals, you must supply exact on-chain proposal numbers directly to the proposalDetail mode input controls rather than relying on list pagination.

How are token amounts like quorum and votesFor represented in the output records?

Numerical values for metrics such as quorum, votesFor, and votesAgainst are normalized into human-readable token units rather than raw on-chain wei integers, allowing immediate comparison and display in dashboards without secondary decimal scaling scripts.

What should I do if a scheduled run encounters a 403 or 429 rate limit response?

The proxyConfiguration input control is available as an optional automatic fallback mechanism. While normal operation requires no proxy costs, enabling Apify proxy settings handles sudden rate limiting or anti-scraping challenges from the host domain.

Where to go next

Start with the Tally (Cactus) 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:

Property listing scrapers covers 25 Actors in this family.
Video and transcript scrapers covers 46 Actors in this family.
Search results scrapers covers 11 Actors in this family.

Readers running Tally (Cactus) DAO Governance Scraper commonly pair it with:

PitchBook Fund Data Scraper Scrape public fund profile metadata from PitchBook without a subscription.
Quora Scraper Scrape Quora questions, answers, user profiles, topics, and spaces.
MLB Stats Scraper Scrape the official MLB Stats API, comprehensive baseball data including teams, players, schedules, standings, and detailed statistics.
Reddit Community Scraper Scrape full community intelligence for any subreddit: description, subscriber count, active users, weekly activity, posting rules, wiki pages, icons/colors and settings - plus optional recent posts.
Fragrantica Perfume Scraper Extract perfume data from Fragrantica.com like name, brand, year, perfumer, fragrance pyramid (top/middle/base notes), main accords, ratings, and reviews.
Indeed Jobs Scraper Scrape jobs from Indeed worldwide.
Website Image Scraper Extract every image URL from a website.
Clutch.co B2B Agency Scraper Extract agency profiles, ratings, reviews, and verified client data from Clutch.co.

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.
Tally (Cactus) DAO Governance Scraper on Apify