Source: https://cryptanio.com/fr/docs/reference/list-chains/
Contract / release / updated: v1 / 1.0.0 62 / 2026-10-10

[Référence de l’API](https://cryptanio.com/fr/docs.html#reference)

# Lister les réseaux

GET `/v1/chains`

Contrat v1 / 1.0.0 62 / 2026-10-10

[Markdown](https://cryptanio.com/fr/docs/reference/list-chains/index.md) [OpenAPI](https://cryptanio.com/openapi.json)

Catalogue des réseaux et confirmations. live indique la disponibilité de la surveillance par l’API publique, pas seulement la prise en charge du format d’adresse. Vérifiez le catalogue actuel avant de rattacher une adresse.

Permissions de la clé : aucune clé requise.

## Exemples de requêtes

Les exemples réalisent une opération réelle dans votre compte. Définissez les variables d’environnement nommées dans le code. Gardez votre clé privée ; les requêtes d’écriture ne sont pas réessayées automatiquement.



### Shell / cURL

```bash
#!/usr/bin/env bash
set -euo pipefail
response_file="$(mktemp)"
trap 'rm -f "$response_file"' EXIT
transfer_status=0
http_status="$(curl \
  --silent --show-error --max-time 30 --request GET \
  --header 'Accept: application/json' \
  "https://api.cryptanio.com/v1/chains" \
  --output "$response_file" --write-out '%{http_code}')" || transfer_status=$?
if [[ "$http_status" == 2?? ]]; then
  cat "$response_file"
  exit "$transfer_status"
fi
printf 'HTTP %s\n' "$http_status" >&2
cat "$response_file" >&2
exit 1
```



[Télécharger l’exemple](https://cryptanio.com/files/examples/api/list-chains.sh)



### Go

```go
// Go; standard library only. Run: go run request.go
package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func env(name string) string {
    value := os.Getenv(name)
    if value == "" { fmt.Fprintln(os.Stderr, "Set", name); os.Exit(1) }
    return value
}
func run() error {
    path := "/v1/chains"

    endpoint, err := url.Parse("https://api.cryptanio.com" + path)
    if err != nil { return err }
    query := endpoint.Query()

    endpoint.RawQuery = query.Encode()

    request, err := http.NewRequest("GET", endpoint.String(), nil)
    if err != nil { return err }
    request.Header.Set("Accept", "application/json")
    client := &http.Client{Timeout: 30 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        body, err := io.ReadAll(response.Body)
        if err != nil { return err }
        return fmt.Errorf("HTTP %d: %s", response.StatusCode, body)
    }
    _, err = io.Copy(os.Stdout, response.Body)
    return err
}
func main() {
    if err := run(); err != nil { fmt.Fprintln(os.Stderr, err); os.Exit(1) }
}
```



[Télécharger l’exemple](https://cryptanio.com/files/examples/api/list-chains.go)



### Rust

```rust
// Cargo.toml dependencies:
// reqwest = { version = "=0.12.24", features = ["blocking", "json"] }
// serde_json = "=1.0.145"
use std::{error::Error, io, time::Duration};
use reqwest::{blocking::Client, redirect::Policy, Method, Url};

fn env(name: &str) -> Result<String, Box<dyn Error>> {
    let value = std::env::var(name)?;
    if value.is_empty() { return Err(format!("Set {name}").into()); }
    Ok(value)
}
fn run() -> Result<(), Box<dyn Error>> {
    let mut url = Url::parse("https://api.cryptanio.com")?;
    {
        let mut segments = url.path_segments_mut().map_err(|_| "Invalid base URL")?;
        segments.clear();
        segments.push("v1");
        segments.push("chains");
    }
    let client = Client::builder().timeout(Duration::from_secs(30)).redirect(Policy::none()).build()?;
    let request = client.request(Method::GET, url)
        .header("Accept", "application/json".to_owned());
    let mut response = request.send()?;
    let status = response.status();
    if !status.is_success() { return Err(format!("HTTP {}: {}", status.as_u16(), response.text()?).into()); }
    io::copy(&mut response, &mut io::stdout())?;
    Ok(())
}
fn main() {
    if let Err(error) = run() { eprintln!("{error}"); std::process::exit(1); }
}
```



[Télécharger l’exemple](https://cryptanio.com/files/examples/api/list-chains.rs)



### PHP

```php
<?php
// PHP 8 with the cURL extension. Run this on your server.
function env(string $name): string {
    $value = getenv($name);
    if ($value === false || $value === '') throw new RuntimeException('Set ' . $name);
    return $value;
}
try {
    $path = '/v1/chains';

    $query = [

    ];
    $url = 'https://api.cryptanio.com' . $path . ($query ? '?' . http_build_query($query, '', '&', PHP_QUERY_RFC3986) : '');
    $headers = [
        'Accept: ' . 'application/json',
    ];
    $curl = curl_init($url);
    curl_setopt_array($curl, [
        CURLOPT_CUSTOMREQUEST => 'GET',
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_FOLLOWLOCATION => false,
        CURLOPT_CONNECTTIMEOUT => 10,
        CURLOPT_TIMEOUT => 30,
    ]);
    $response = curl_exec($curl);
    if ($response === false) throw new RuntimeException(curl_error($curl));
    $status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    if ($status < 200 || $status >= 300) throw new RuntimeException('HTTP ' . $status . ': ' . $response);
    echo $response;
} catch (Throwable $error) {
    fwrite(STDERR, $error->getMessage() . PHP_EOL);
    exit(1);
}
```



[Télécharger l’exemple](https://cryptanio.com/files/examples/api/list-chains.php)



### Python

```python
# Python 3; standard library only.
import json
import os
import sys
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlencode
from urllib.request import HTTPRedirectHandler, Request, build_opener

def env(name):
    result = os.environ.get(name)
    if not result:
        raise ValueError("Set " + name)
    return result

class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

try:
    path = "/v1/chains"

    query = {

    }
    url = "https://api.cryptanio.com" + path + ("?" + urlencode(query) if query else "")
    headers = {
        "Accept": "application/json",
    }
    data = None
    request = Request(url, data=data, headers=headers, method="GET")
    with build_opener(NoRedirect()).open(request, timeout=30) as response:
        if not 200 <= response.status < 300:
            raise ValueError("HTTP " + str(response.status))
        sys.stdout.buffer.write(response.read())
except HTTPError as error:
    print("HTTP " + str(error.code) + ": " + error.read().decode("utf-8", errors="replace"), file=sys.stderr)
    sys.exit(1)
except (ValueError, URLError, OSError) as error:
    print(str(error), file=sys.stderr)
    sys.exit(1)
```



[Télécharger l’exemple](https://cryptanio.com/files/examples/api/list-chains.py)



### Node.js

```javascript
// Node.js 18+. Run on your server, never in a browser.
const env = name => {
  const result = process.env[name];
  if (!result) throw new Error(`Set ${name}`);
  return result;
};
try {
  let path = "/v1/chains";

  const url = new URL(path, "https://api.cryptanio.com");

  const headers = {
    "Accept": "application/json",
  };
  const response = await fetch(url, {
    method: "GET", headers, redirect: "manual",
    signal: AbortSignal.timeout(30_000),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  if (response.body) {
    for await (const chunk of response.body) process.stdout.write(chunk);
  }
} catch (error) {
  console.error(error.message);
  process.exitCode = 1;
}
```



[Télécharger l’exemple](https://cryptanio.com/files/examples/api/list-chains.mjs)

## Réponses et erreurs

### 200 Réponse réussie.

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `data` | `object[]` | Oui |  |

[Gestion des erreurs et nouvelles tentatives sûres](https://cryptanio.com/fr/docs.html#errors)

## Objets imbriqués

### `ChainList`

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `data` | `object[]` | Oui |  |

### `Chain`

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `chain` | `string` | Oui | Code réseau pour les requêtes. |
| `title` | `string` | Oui | Nom du réseau. |
| `native_coin` | `string` | Oui | Monnaie native. |
| `decimals` | `integer` | Oui | Décimales de la monnaie native.; minimum: `0` |
| `token_standard` | `string` | Non | Standard de token pris en charge. |
| `stablecoins` | `string[]` | Non | Symboles connus des stablecoins de paiement. |
| `pending_in` | `string` | Oui | Détection pending attendue. |
| `confirmed_in` | `string` | Oui | Confirmation attendue. |
| `caveat` | `string` | Non | Précision propre au réseau. |
| `live` | `boolean` | Oui | La surveillance de transactions blockchain réelles est disponible dans l’API publique. La seule prise en charge du format d’adresse ne la garantit pas. |