# DAO Proposals — Onchain Verified (`junkalwaysshine/apix402-dao-governance`) Actor

ENS, Arbitrum, Uniswap DAO governance proposals verified onchain, not just Snapshot. Catches votes trackers miss — like Arbitrum's silent 48M ARB proposal.

- **URL**: https://apify.com/junkalwaysshine/apix402-dao-governance.md
- **Developed by:** [Junk always shine](https://apify.com/junkalwaysshine) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

### What this Actor does

Shows DAO governance votes checked directly against each DAO's own Governor contract — not just [Snapshot](https://snapshot.org), the offchain temperature-check layer most trackers show. Covers **ENS, Arbitrum, and Uniswap** today.

This is not another Snapshot mirror. Public trackers can be wrong or simply silent. While building this, we found a well-known public tracker showing Arbitrum's DAO as archived — zero active proposals — while its Governor contract had a live, binding vote on **48M ARB** with a deadline days away. An agent trusting only the tracker would have missed it entirely. The `discrepancy` field exists specifically to catch this class of failure.

### Usage scenario

A trading agent tracks governance for DAOs whose tokens it holds or trades. It needs to catch votes that could move price or liquidity — without blindly trusting one external source that might be stale, incomplete, or simply wrong.

**Input** — optional filter by a single DAO:

```json
{ "dao": "ENS" }
```

Leave `dao` empty to fetch all three configured DAOs in one run.

### Example output

One real dataset item (trimmed to the fields that matter most for evaluating a proposal — the full field list is in the Output tab):

```json
{
  "dao": "ENS",
  "proposal_id": "80619211450810140112687536515944199882433060764177806587986222097717655810120",
  "sources": ["onchain"],
  "title": "Proposal #806192114508…",
  "vote_type": "onchain_binding",
  "status": "active",
  "closes_at": "2026-08-08T21:10:45.413Z",
  "votes": { "for": "1146479.618632655947352941", "against": "387647.529426331501519092", "abstain": "0", "unit": "ENS" },
  "after_close": {
    "code": "onchain_timelock",
    "detail": "Onchain vote. If it passes, it enters the Timelock queue and becomes executable after the contract's delay."
  },
  "discrepancy": "This ENS onchain vote is live right now, but Snapshot shows zero active or pending proposals for this DAO — the offchain signal stays silent about it.",
  "onchain_verified_at": "2026-08-06T07:14:00.340Z",
  "fetched_at": "2026-08-06T07:14:00.340Z"
}
```

`discrepancy` is `null` when the two sources agree — that's the common case. When it isn't `null`, that's the actual product: a signal the offchain layer alone would have missed. `sources_status` in the run's key-value output shows, per DAO, whether Snapshot and onchain each answered fully — never a silently incomplete result.

### Configuration

| Input field | Required | Meaning |
|---|---|---|
| `dao` | No | Filter to a single DAO: `ENS`, `Arbitrum`, or `Uniswap`. Omit to fetch all three. |

No API key, no account, no proxy configuration needed — this Actor reads directly from Snapshot's public GraphQL API and each DAO's own Governor contract via public RPC endpoints.

### FAQ

**Why not just use Snapshot directly?** Snapshot only shows what was submitted through it. ENS, Arbitrum, and Uniswap all also run binding, execution-triggering votes directly through their Governor contract — votes that can be missing from Snapshot entirely, or behind on indexing. Missing those means missing the votes that actually change something onchain.

**What does a run cost?** A typical run (all three DAOs) takes a few seconds and a small, fixed amount of compute.

**Does it collect personal data?** No. Every field is onchain or public-governance data — proposal text, vote tallies, wallet addresses, contract links. No names, emails, or other personal identifiers.

# Actor input Schema

## `dao` (type: `string`):

One of the configured DAOs: ENS, Arbitrum, Uniswap. Leave empty for all.

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("junkalwaysshine/apix402-dao-governance").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("junkalwaysshine/apix402-dao-governance").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 '{}' |
apify call junkalwaysshine/apix402-dao-governance --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,junkalwaysshine/apix402-dao-governance"
        }
    }
}

```

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/zd63ZvWkSFt7p5VaJ/builds/nJJDwhSzxn2zqwseh/openapi.json