> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Comment rechercher l'identité d'un portefeuille Solana
> Identifiez les portefeuilles Solana connus par adresse ou par domaine SNS/ANS. Recherchez des entrées uniques ou traitez par lots jusqu'à 100 adresses et domaines à la fois.
L'API Wallet est en version bêta. Les points de terminaison et les formats de réponse peuvent changer.
## Aperçu
Le point de terminaison d'identité du portefeuille identifie les adresses de portefeuilles connues sur Solana, y compris les échanges centralisés, les protocoles DeFi, les institutions et d'autres entités reconnues. Utilisez-le pour la conformité, l'analyse et l'affichage de noms lisibles pour les adresses connues.
Les points de terminaison unique (`GET /v1/wallet/{wallet}/identity`) et par lots (`POST /v1/wallet/batch-identity`, jusqu'à 100 entrées) acceptent **les domaines SNS `.sol`** et **les TLD personnalisés ANS** (par exemple `.bonk`, `.poor`, `.abc`) en plus des adresses brutes Solana. La résolution de domaine est uniquement sur le réseau principal.
Ce point de terminaison utilise le même système d'identité qui alimente [Orb](https://orbmarkets.io/), l'explorateur de blocs Helius Solana. La base de données comprend plus de 32 500 étiquettes (noms principaux lisibles par l'homme, y compris plus de 3 000 programmes) et plus de 21,5 millions d'étiquettes (propriétés catégoriques comme "Adresse de dépôt Binance" ou "Téléphone Seeker"), et est en croissance continue.
Les points de terminaison unique (`GET /v1/wallet/{wallet}/identity`) et par lots (`POST /v1/wallet/batch-identity`) nécessitent un plan payant. Les requêtes effectuées avec une clé API de plan gratuit renvoient `403 Forbidden`. Voir [Exigences du plan](/docs/fr/wallet-api/overview#exigences-du-plan) pour la couverture complète.
## Quand l'utiliser
Utilisez l'API Wallet Identity lorsque vous devez :
* **Identifier les portefeuilles d'échange** : déterminer si un portefeuille appartient à Binance, Coinbase, Kraken, et d'autres.
* **Suivre l'activité des protocoles** : identifier les portefeuilles des protocoles DeFi et les adresses des trésoreries.
* **Conformité et LBC** : signaler les transactions impliquant des entités connues.
* **Analytique** : catégoriser les types de portefeuilles dans votre pipeline de données.
* **Expérience utilisateur** : afficher "Envoyé à Binance 1" au lieu d'une adresse brute.
* **Traitement par lots** : rechercher efficacement des centaines d'adresses.
## Démarrage rapide
### Recherche d'un portefeuille unique
Recherchez des informations d'identité pour une adresse de portefeuille unique :
```javascript theme={"system"}
const getWalletIdentity = async (address) => {
const url = `https://api.helius.xyz/v1/wallet/${address}/identity?api-key=YOUR_API_KEY`;
const response = await fetch(url);
if (!response.ok) {
if (response.status === 404) {
console.log("No identity found for this address");
return null;
}
throw new Error(`HTTP error! status: ${response.status}`);
}
const identity = await response.json();
console.log(`Found: ${identity.name} (${identity.category})`);
return identity;
};
// Example: Binance wallet
getWalletIdentity("HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664");
```
```python theme={"system"}
import requests
def get_wallet_identity(address: str):
url = f"https://api.helius.xyz/v1/wallet/{address}/identity"
headers = {"X-Api-Key": "YOUR_API_KEY"}
response = requests.get(url, headers=headers)
if response.status_code == 404:
print("No identity found for this address")
return None
response.raise_for_status()
identity = response.json()
print(f"Found: {identity['name']} ({identity['category']})")
return identity
# Example: Binance wallet
get_wallet_identity("HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664")
```
```bash theme={"system"}
curl "https://api.helius.xyz/v1/wallet/HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664/identity?api-key=YOUR_API_KEY"
```
#### Rechercher par nom de domaine
Vous pouvez également passer un domaine SNS `.sol` ou un TLD personnalisé ANS directement — le point de terminaison résout le domaine et renvoie l'identité de l'adresse propriétaire :
```javascript theme={"system"}
// Works identically — the endpoint resolves the domain first.
const identity = await getWalletIdentity("toly.sol");
// ANS custom TLD
await getWalletIdentity("miester.bonk");
```
```python theme={"system"}
# Works identically — the endpoint resolves the domain first.
identity = get_wallet_identity("toly.sol")
# ANS custom TLD
get_wallet_identity("miester.bonk")
```
```bash theme={"system"}
# SNS (.sol) domain
curl "https://api.helius.xyz/v1/wallet/toly.sol/identity?api-key=YOUR_API_KEY"
# ANS custom TLD
curl "https://api.helius.xyz/v1/wallet/miester.bonk/identity?api-key=YOUR_API_KEY"
```
La réponse du point de terminaison unique est l'objet d'identité standard pour l'adresse **résolue** — il n'y a pas de marqueur `inputDomain`. Si vous devez corréler les entrées avec les sorties (par exemple, lors de la recherche de nombreux domaines à la fois), utilisez le point de terminaison par lots.
La résolution de domaine est uniquement sur le réseau principal. Sur devnet/testnet, une entrée de domaine à ce point de terminaison renvoie `400`. Les résolutions positives sont mises en cache jusqu'à 2 heures, donc un domaine récemment transféré peut brièvement se résoudre à l'identité de l'ancien propriétaire.
### Recherche par lots (jusqu'à 100 entrées)
Recherchez plusieurs entrées dans une seule demande pour de meilleures performances. Chaque entrée peut être soit une adresse soit un nom de domaine :
```javascript theme={"system"}
const batchIdentityLookup = async (addresses) => {
const url = "https://api.helius.xyz/v1/wallet/batch-identity?api-key=YOUR_API_KEY";
const response = await fetch(url, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({ addresses })
});
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const identities = await response.json();
return identities;
};
// Example: Mix addresses and domains in a single request
const addresses = [
"HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664", // Binance (address)
"toly.sol", // SNS domain
"miester.bonk" // ANS custom TLD
];
batchIdentityLookup(addresses).then(identities => {
identities.forEach(identity => {
if (identity.unresolved) {
console.log(`${identity.inputDomain}: could not be resolved`);
return;
}
const label = identity.inputDomain
? `${identity.inputDomain} → ${identity.address}`
: identity.address;
console.log(`${label}: ${identity.name}`);
});
});
```
```python theme={"system"}
import requests
def batch_identity_lookup(addresses: list[str]):
url = "https://api.helius.xyz/v1/wallet/batch-identity"
headers = {
"X-Api-Key": "YOUR_API_KEY",
"Content-Type": "application/json"
}
response = requests.post(
url,
headers=headers,
json={"addresses": addresses}
)
response.raise_for_status()
return response.json()
# Example: Mix addresses and domains in a single request
addresses = [
"HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664", # Binance (address)
"toly.sol", # SNS domain
"miester.bonk" # ANS custom TLD
]
identities = batch_identity_lookup(addresses)
for identity in identities:
if identity.get("unresolved"):
print(f"{identity['inputDomain']}: could not be resolved")
continue
label = f"{identity['inputDomain']} -> {identity['address']}" if identity.get("inputDomain") else identity["address"]
print(f"{label}: {identity['name']}")
```
```bash theme={"system"}
curl -X POST "https://api.helius.xyz/v1/wallet/batch-identity?api-key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"addresses": [
"HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664",
"toly.sol",
"miester.bonk"
]
}'
```
## Format de réponse
Une recherche unique réussie renvoie l'objet d'identité pour l'adresse résolue :
```json theme={"system"}
{
"address": "HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664",
"type": "exchange",
"name": "Binance 1",
"category": "Centralized Exchange",
"tags": ["Centralized Exchange"]
}
```
Dans une réponse **par lots**, toute entrée dont l'entrée était un nom de domaine comporte un champ `inputDomain` supplémentaire afin que vous puissiez corréler la réponse avec la demande d'origine :
```json theme={"system"}
{
"address": "7v91N7iZ9mNicL8WfG6cgSCKyRXydQjLh6UYBWwm6y1Q",
"type": "wallet",
"name": "toly",
"category": "Key Opinion Leader",
"tags": ["Key Opinion Leader"],
"inputDomain": "toly.sol"
}
```
Lorsqu'un domaine dans une demande par lots ne peut pas être résolu, le lot ne tombe pas en panne — l'entrée est retournée à la place avec `address: null`, `type: "unknown"`, et `unresolved: true`. L'ordre des demandes est préservé :
```json theme={"system"}
{
"address": null,
"type": "unknown",
"inputDomain": "nonexistent-xyz.sol",
"unresolved": true
}
```
Sur le point de terminaison **unique**, un 404 est retourné si le portefeuille n'a pas d'entrée d'identité **ou** si une entrée de domaine n'a pas pu être résolue :
```json theme={"system"}
{
"error": "No identity information available for this address",
"code": 404
}
```
```json theme={"system"}
{
"error": "Domain 'nonexistent-xyz.sol' could not be resolved",
"code": 404
}
```
### Catégories d'identité
Les portefeuilles et les programmes sont classés en catégories alimentées par la base de données d'identité Orb. Les comptes et les programmes utilisent des ensembles de catégories distincts. Les tableaux ci-dessous listent chaque catégorie prise en charge.
| Catégorie | Description | Exemples |
| ---------------------------- | ---------------------------------------------------- | --------------------------------------------------------------- |
| Échange centralisé | Portefeuilles CEX et portefeuilles chauds | Binance 1, Coinbase 1, Kraken, OKX Exchange 1, Bybit Hot Wallet |
| Pont inter-chaînes | Adresses de protocoles de pont | Wormhole Bridge, AllBridge, Portal Bridge, deBridge |
| DeFi | Adresses de protocoles DeFi | Jupiter, Raydium, Orca, Marinade Finance, Kamino |
| Leader d'opinion clé | Personnes et influenceurs notables | Anatoly Yakovenko, Raj Gokal |
| Market Maker | Entreprises de création de marché | Jump Trading, Wintermute, GSR Markets |
| Entreprise de trading | Entreprises de trading propriétaire | Alameda Research, DRW Trading |
| Validateur | Adresses de validateurs et de pools de participation | Coinbase Validator, Jito Validator, Figment Validator |
| Trésorerie | Trésoreries de projets et de protocoles | Marinade Treasury, Helium Treasury, Solana Foundation Treasury |
| DAO | Organisations autonomes décentralisées | Mango DAO, Grape DAO, MonkeDAO Treasury |
| NFT | Marchés et projets NFT | Magic Eden, Tensor, OpenSea Solana, DeGods Treasury |
| Pool de participation | Adresses de pools de participation liquide | Marinade Stake Pool, Jito Stake Pool, BlazeStake |
| Multisig | Portefeuilles à signatures multiples | Squads Multisig, Solana Foundation Multisig |
| Oracle | Fournisseurs de flux de prix et d'oracles | Pyth Network, Switchboard Oracle, Chainlink Solana |
| Jeu | Projets de jeux et de GameFi | Star Atlas, Aurory, Genopets Treasury |
| Paiements | Processeurs de paiements | Solana Pay, Sphere, Helio Pay |
| Outils | Outils et utilitaires pour développeurs | Phantom Wallet, Backpack, Solflare Wallet |
| Airdrop | Adresses de distribution d'airdrop | Jupiter Airdrop, Pyth Airdrop Distributor |
| Gouvernance | Adresses de programmes de gouvernance | Realms Governance, SPL Governance |
| Autorité | Autorités de programme et administrateurs | Token Program Authority, Metaplex Authority |
| Jito | Adresses spécifiques à Jito | Jito Tip 1, Jito Tip 2, Jito MEV Payment |
| Memecoin | Projets Memecoin | Bonk Treasury, Dogwifhat, Book of Meme |
| Casino & Jeux d'argent | dApps de casino et de jeux d'argent | Stake.com Hot Wallet, Rollbit, DexSport |
| DePIN | Infrastructure physique décentralisée | Helium Network, Render Network, Hivemapper |
| AMM propriétaire | Implémentations AMM personnalisées | Phoenix DEX, GooseFX |
| Restaking | Protocoles de restaking | Solayer, Fragmetric |
| Coffre-fort | Adresses de coffre-fort et de garde | Solend Vault, Tulip Vault, Francium Vault |
| Frais | Adresses de collecte de frais | Jupiter Fee Collector, Raydium Fees |
| Collecte de fonds | Adresses de collecte de fonds et d'ICO | Token Sale Wallet, Fundraise Multisig |
| Distribution du bloc Genesis | Adresses de distribution de Genesis | Solana Genesis Distribution |
| Offre non circulante | Adresses de tokens non circulants | Team Vesting Wallet, Foundation Reserve |
| Envoi de transactions | Services d'envoi de transactions | Jito Tip 1, Jito Tip 2, Helius Sender Tip 1 |
| Système | Programmes système Solana | System Program, Config Program |
| X402 | Adresses de protocole X402 | X402 Protocol |
| Autre | Adresses connues non classées | Divers portefeuilles connus |
| Catégorie | Description | Exemples |
| ------------------------------ | ------------------------------------- | ----------------------------------------------------------------- |
| Exploitant, Hackers & Arnaques | Adresses connues d'exploit et de hack | Wormhole Exploiter Wallet, SagaDAO Hacker Wallet, Mango Exploiter |
| Hacker | Adresses de hackers confirmés | Solana Hack 2022, DeFi Protocol Hacker |
| Rugger | Auteurs de rug pulls | Squid Game Token Rugger, Known Rug Pull Wallet |
| Escroc | Adresses d'escroquerie confirmées | Faux Airdrop Scammer, Phishing Scam Wallet |
| Spam | Créateurs de tokens de spam | Spam Token Creator, Airdrop Spammer |
Les programmes (contrats intelligents) sont classés séparément :
| Catégorie | Description | Exemples |
| ------------------------------ | ------------------------------------ | ---------------------- |
| Échange | Protocoles d'échange de tokens | Jupiter, Raydium, Orca |
| DeFi | Protocoles DeFi généraux | Drift, Mango |
| Emprunt Prêt | Protocoles de prêt | Solend, MarginFi |
| NFT | Marchés NFT | Magic Eden, Tensor |
| Jalonnement | Programmes de jalonnement | Marinade, Jito |
| Pont | Ponts inter-chaînes | Wormhole, AllBridge |
| Agrégateur | Agrégateurs DEX | Jupiter Aggregator |
| Perpétuels | Contrats à terme perpétuels | Drift, Mango |
| Oracle | Fournisseurs d'oracle | Pyth, Switchboard |
| Lancement | Plates-formes de lancement de tokens | Raydium Launchpad |
| Gouvernance | Programmes de gouvernance | SPL Governance |
| Jeu ou Casino | Programmes de jeu | Star Atlas |
| Marché de prédiction | Marchés de prédiction | Drift Predictions |
| Paiements | Protocoles de paiement | Solana Pay |
| Confidentialité | Protocoles de confidentialité | Elusiv |
| Compression | Compression d'état | Bubblegum |
| Infrastructure | Infrastructure de base | Metaplex |
| Outils | Outils pour développeurs | Clockwork |
| RWA | Actifs du monde réel | Ondo Finance |
| DePIN | Infrastructure décentralisée | Helium, Render |
| DeSci | Science décentralisée | VitaDAO |
| Airdrop | Programmes d'airdrop | Merkle distributors |
| Web3 | Applications Web3 | Divers |
| Native | Programmes natifs Solana | System Program |
| AMM propriétaire | Conceptions AMM personnalisées | Phoenix |
| Trading Sniper | Bots de trading | MEV bots |
| Bot d'arbitrage ou de sandwich | Bots MEV et arb | Jito bundles |
| Spam | Programmes de spam | Spam tokens |
| Autre | Programmes non classés | Divers |
## Cas d'utilisation
### Signaler les dépôts d'échange
Identifier quand des fonds sont envoyés à un échange centralisé :
```javascript theme={"system"}
const checkIfExchange = async (address) => {
try {
const identity = await getWalletIdentity(address);
if (identity && identity.category === "Centralized Exchange") {
console.log(`Funds sent to ${identity.name}`);
return true;
}
} catch (error) {
// Not a known exchange
}
return false;
};
```
### Afficher des noms lisibles
Afficher des noms conviviaux dans votre interface utilisateur au lieu d'adresses :
```javascript theme={"system"}
const getDisplayName = async (address) => {
try {
const identity = await getWalletIdentity(address);
return identity ? identity.name : shortenAddress(address);
} catch (error) {
return shortenAddress(address);
}
};
// Usage in UI
const displayName = await getDisplayName("HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664");
// Returns: "Binance 1" instead of "HXsKP...G664"
```
### Traiter par lots les contreparties des transactions
Identifier efficacement toutes les contreparties dans une liste de transactions :
```javascript theme={"system"}
const identifyTransactionCounterparties = async (transactions) => {
// Extract all unique addresses
const addresses = [...new Set(
transactions.map(tx => tx.counterparty)
)];
// Batch lookup (up to 100 at a time)
const allIdentities = [];
for (let i = 0; i < addresses.length; i += 100) {
const chunk = addresses.slice(i, i + 100);
const identities = await batchIdentityLookup(chunk);
allIdentities.push(...identities);
}
// Create a map for quick lookup
const identityMap = new Map(
allIdentities.map(id => [id.address, id])
);
// Enrich transactions with identity info
return transactions.map(tx => ({
...tx,
counterpartyName: identityMap.get(tx.counterparty)?.name || "Unknown"
}));
};
```
## Bonnes pratiques
* **Utilisez le point de terminaison par lots pour plusieurs recherches.** Lorsque vous recherchez plus d'une adresse, `POST /v1/wallet/batch-identity` est significativement plus rapide que de faire des demandes individuelles.
* **Gérez gracieusement les réponses 404.** Tous les portefeuilles n'ont pas d'informations d'identité. Revenir à l'affichage de l'adresse brute.
* **Mettez en cache les résultats.** Les données d'identité changent rarement. Mettez en cache localement pour réduire les appels API.
* **Respectez la limite de taille des lots.** Le point de terminaison par lots prend en charge jusqu'à 100 entrées par demande. Découpez les ensembles de données plus importants en conséquence.
## Erreurs courantes
| Code d'erreur | Description | Solution |
| ------------- | ----------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Format d'adresse ou de domaine de portefeuille invalide, ou entrée de domaine non-mainnet | Vérifiez que l'entrée est une adresse Solana base58 valide ou un domaine bien formé (par exemple `toly.sol`), et que vous ciblez le réseau principal |
| 401 | Clé API manquante ou invalide | Vérifiez que votre clé API est incluse dans la demande |
| 403 | Le point de terminaison nécessite un plan payant | Les recherches d'identité ne sont pas disponibles sur le plan gratuit. [Mettez à niveau votre plan](https://dashboard.helius.dev) vers un niveau payant |
| 404 | Aucune identité trouvée, ou le domaine n'a pas pu être résolu | Point de terminaison unique uniquement — le portefeuille n'a pas d'entrée d'identité, ou le domaine n'existe pas. Dans les demandes par lots, les domaines non résolvables sont retournés en tant qu'entrées `unresolved: true` plutôt que 404 |
| 429 | Limite de débit dépassée | Réduisez la fréquence des demandes ou mettez à niveau votre plan |
## Prochaines étapes
Suivez qui a initialement financé un portefeuille — les types de financeurs réutilisent ces catégories d'identité.
Tous les points de terminaison de l'API Wallet et les conventions partagées.
Schémas de demande et de réponse pour la recherche d'identité.