Skip to main content
ZKScore Hero Light

​
What is ZKScore?

ZKScore is a comprehensive reputation and identity protocol that enables developers to build trust-enabled applications with privacy-preserving scores. Our platform combines on-chain identity, verifiable reputation scoring, and zero-knowledge proofs to create a new paradigm for trust in Web3.

Privacy-First Architecture

Zero-knowledge proofs ensure users maintain control over their data while proving reputation

Soulbound Identity

Non-transferable NFT identities that represent unique individuals across chains

Dynamic Scoring

Real-time reputation scores based on on-chain activity, achievements, and attestations

Trust Layer

Flexible attestation system for building custom trust frameworks

​
Key Features

​
🔐 Soulbound Identities

Create unique, non-transferable identities represented as NFTs. Each identity is bound to an individual and serves as the foundation for building reputation. 
import { ZKScoreSDK } from '@zkscore/sdk';

const sdk = new ZKScoreSDK({ apiKey: 'your-api-key' });

// Mint a new identity
const identity = await sdk.identity.mint({
  address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1',
  username: 'alice',
});

​
📊 Reputation Scoring

Dynamic scoring system that evaluates on-chain behavior across multiple dimensions:
  • Wallet Age: Time since wallet creation
  • Transaction Volume: Total transaction count and value
  • DeFi Activity: Interactions with DeFi protocols
  • NFT Holdings: Quality and diversity of NFT collection
  • Social Reputation: Community engagement and attestations
  • Achievement Progress: Milestone completions
// Get comprehensive score
const score = await sdk.scores.getScore('0x742d35...');

console.log(score);
// {
//   overall: 850,
//   breakdown: {
//     walletAge: 95,
//     transactions: 78,
//     defi: 88,
//     nfts: 72,
//     social: 85
//   }
// }

​
🏆 Achievement System

Gamified achievement system that rewards users for completing milestones and demonstrating expertise.
  • Pre-built achievement templates
  • Custom achievement creation
  • On-chain verification
  • NFT badges and rewards
// Get user achievements
const achievements = await sdk.achievements.getUserAchievements(
  '0x742d35...'
);

// Claim an achievement
await sdk.achievements.claim({
  achievementId: 'defi-expert',
  proof: zkProof,
});

​
🔒 Zero-Knowledge Proofs

Prove reputation without revealing sensitive data. Users can generate ZK proofs to verify:
  • Score thresholds (e.g., “score > 700”)
  • Specific achievements
  • Attestations
  • Historical activity
// Generate a ZK proof
const proof = await sdk.zkProofs.generate({
  type: 'score-threshold',
  threshold: 700,
  hideExactScore: true,
});

// Verify proof
const isValid = await sdk.zkProofs.verify(proof);

​
✅ Trust Layer & Attestations

Flexible attestation framework for building custom trust systems:
  • Protocol-specific attestations
  • Multi-signature attestations
  • Time-bound attestations
  • Revocable attestations
// Create an attestation
const attestation = await sdk.trustLayer.createAttestation({
  subject: '0x742d35...',
  schema: 'kyc-verification',
  data: {
    verified: true,
    level: 'tier-2',
    expiresAt: '2025-12-31',
  },
});

​
Use Cases

DeFi Lending

Undercollateralized lending based on reputation scores

NFT Gating

Gate access to exclusive NFT mints and communities

DAO Governance

Weighted voting based on expertise and contribution

Social Platforms

Verify user identity and build trust in social apps

Gaming

Create player rankings and anti-sybil systems

Marketplaces

Build seller reputation and buyer protection

​
Architecture Overview

ZKScore is built on a modular architecture that separates concerns and enables flexibility:

​
Components

  • Smart Contracts: On-chain identity, scoring, and attestation logic
  • REST API: High-level API for querying data and generating proofs
  • Indexer: Real-time event processing and score calculation
  • SDK: Client libraries for JavaScript, TypeScript, and React
  • Score Engine: Advanced scoring algorithms and analytics

​
Getting Started

Quickstart

Get up and running in 5 minutes

API Reference

Explore the complete API documentation

SDK Documentation

Learn how to use our SDKs

Smart Contracts

Direct contract integration guide

​
Supported Networks

ZKScore is deployed on multiple EVM-compatible networks:

Ethereum Mainnet

Full production deployment

Base

Low-cost L2 deployment

Polygon

High-throughput sidechain

Arbitrum

Optimistic rollup deployment

Optimism

Optimistic rollup deployment

BSC

Binance Smart Chain

​
Why ZKScore?

​
For Developers

  • Easy Integration: Simple SDK with TypeScript support
  • Flexible: Build custom scoring models and attestation schemas
  • Privacy-Preserving: ZK proofs protect user data
  • Multi-chain: Deploy on any EVM-compatible network
  • Well-Documented: Comprehensive guides and examples

​
For Users

  • Own Your Reputation: Portable identity across applications
  • Privacy First: Control what you share with ZK proofs
  • Earn Rewards: Achievements and badges for on-chain activity
  • Build Trust: Verifiable reputation without centralized platforms
  • No Vendor Lock-in: Export your data anytime

​
For Protocols

  • Reduce Risk: Better assess user trustworthiness
  • Prevent Sybils: One identity per person
  • Increase Engagement: Gamification and achievements
  • Custom Trust Models: Define your own attestation schemas
  • Interoperable: Leverage reputation across the ecosystem

​
Community & Support

Discord Community

Join our developer community

GitHub

Contribute to the codebase

Twitter

Follow for updates

Blog

Read our latest articles

​
What’s Next?

1

Read the Quickstart

Get your first identity and score in 5 minutes Start here →
2

Understand Core Concepts

Learn about identities, scoring, and attestations Core Concepts →
3

Integrate the SDK

Add ZKScore to your application SDK Docs →
4

Deploy to Production

Launch your trust-enabled application Deployment Guide →
Need help? Join our Discord or reach out on Twitter