Retrieve Data from the Network

Use antd to retrieve existing public data from the Autonomi Network without wallet setup. This is the simplest read-only flow through the daemon before you decide whether your application also needs uploads.

If you would rather use shell commands without running antd, see Use the CLI. If you want daemon-free Rust access, see Build Directly in Rust.

Featured examples on this page use cURL, Python, Node.js / TypeScript, and Rust. Other SDK languages are available in the Language Bindings section.

Prerequisites

antd installed, running, and healthy on http://localhost:8082 (see Start the Local Daemon)
An existing public address to retrieve. If you do not have one yet, follow Store Data on the Network first.
Optional: the runtime or toolchain for the SDK examples you want to run, such as Python, Node.js, or Rust

For private retrieval, you also need the DataMap. Use Build Read-Only Features if you want the broader read-only flow, including private data.

Steps

Check the daemon is healthy

curl http://localhost:8082/health

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const status = await client.health();
  console.log(status.network);
  console.log(status.ok);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

use antd_client::{Client, DEFAULT_BASE_URL};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let status = client.health().await?;

    println!("{}", status.network);
    println!("{}", status.ok);
    Ok(())
}

Expected REST response:

{
  "status": "ok",
  "network": "default"
}

Retrieve public data from an existing address

Use a public address from another application, another developer, or a previous write. If you do not already have one, follow Store Data on the Network first, then come back to this page.

ADDRESS="<public_address>"

curl "http://localhost:8082/v1/data/public/$ADDRESS"

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const data = await client.dataGetPublic("<public_address>");
  console.log(data.toString());
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

use antd_client::{Client, DEFAULT_BASE_URL};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let data = client.data_get_public("<public_address>").await?;

    println!("{}", String::from_utf8_lossy(&data));
    Ok(())
}

Confirm the response shape

The REST API returns base64 inside JSON:

{
  "data": "SGVsbG8sIEF1dG9ub21pIQ=="
}

The SDK bindings decode the bytes for you, so the Python, Node.js / TypeScript, and Rust examples print the retrieved content directly.

If you need to retrieve private content next, continue to Build Read-Only Features for the DataMap workflow.

What happened

antd accepted your read request, fetched the existing content from the network, and returned it without any wallet setup. Public retrieval only needs a known public address because the storage payment was already handled when the data was written.

Next steps

PreviousStart the Local Daemon NextStore Data on the Network

Last updated 1 day ago

hashtagPrerequisites

hashtagSteps

hashtagCheck the daemon is healthy

hashtagRetrieve public data from an existing address

hashtagConfirm the response shape

hashtagWhat happened

hashtagNext steps