Store and Retrieve Data with the SDKs

In this guide, you use antd, the local daemon used by the SDKs, to store public data, private data, and files through language SDKs.

If you want direct shell access instead, see Use the CLI. If you want direct programmatic Rust access without the daemon, 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 running on http://localhost:8082 (see Start the Local Daemon)

• For the write examples on this page, a write-enabled daemon. On the default network, restart antd with wallet configuration first. On a local devnet, ant dev start provisions that for you. See Prepare a Wallet for Uploads for the default-network setup.

• Optional: the runtime or toolchain for the SDK examples you want to run, such as Python, Node.js, or Rust

The read examples work with any running daemon if you already have an address or DataMap. The write examples on this page require the write-enabled setup above.

Steps

1. Store public data

cURL

DATA_B64=$(printf 'Hello, Autonomi!' | base64)

curl -X POST http://localhost:8082/v1/data/public \
  -H "Content-Type: application/json" \
  -d "{\"data\":\"$DATA_B64\"}"

Python

from antd import AntdClient

client = AntdClient()
result = client.data_put_public(b"Hello, Autonomi!")

print(result.address)

Node.js / TypeScript

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const result = await client.dataPutPublic(Buffer.from("Hello, Autonomi!"));
  console.log(result.address);
}

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

Rust

use antd_client::{Client, DEFAULT_BASE_URL, PaymentMode};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let result = client
        .data_put_public(b"Hello, Autonomi!", PaymentMode::Auto)
        .await?;

    println!("{}", result.address);
    Ok(())
}

2. Retrieve public data

cURL

curl http://localhost:8082/v1/data/public/<address>

Python

from antd import AntdClient

client = AntdClient()
data = client.data_get_public("<address>")

print(data.decode())

Node.js / TypeScript

import { createClient } from "antd";

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

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

Rust

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("<address>").await?;

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

The REST response uses base64 in the data field. The Python, Node.js / TypeScript, and Rust SDKs decode it back into bytes.

3. Store private data

Private uploads return a serialized DataMap. The DataMap is not stored on-network; keep it to retrieve the data later.

cURL

DATA_B64=$(printf 'Secret message' | base64)

curl -X POST http://localhost:8082/v1/data \
  -H "Content-Type: application/json" \
  -d "{\"data\":\"$DATA_B64\"}"

Expected response shape:

{
  "data_map": "<hex_encoded_datamap>",
  "chunks_stored": <chunk_count>,
  "payment_mode_used": "auto"
}

Python

from antd import AntdClient

client = AntdClient()
result = client.data_put(b"Secret message")

data_map = result.data_map
print(data_map)

Node.js / TypeScript

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const result = await client.dataPut(Buffer.from("Secret message"));
  const dataMap = result.dataMap;
  console.log(dataMap);
}

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

Rust

use antd_client::{Client, DEFAULT_BASE_URL, PaymentMode};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let result = client.data_put(b"Secret message", PaymentMode::Auto).await?;

    let data_map = result.data_map;
    println!("{}", data_map);
    Ok(())
}

The Python and Rust SDKs surface the DataMap through DataPutResult.data_map; the Node.js / TypeScript SDK uses DataPutResult.dataMap.

4. Retrieve private data

cURL

curl -X POST http://localhost:8082/v1/data/get \
  -H "Content-Type: application/json" \
  -d '{"data_map":"<hex_encoded_datamap>"}'

Python

from antd import AntdClient

client = AntdClient()
data = client.data_get("<hex_encoded_datamap>")

print(data.decode())

Node.js / TypeScript

import { createClient } from "antd";

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

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

Rust

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("<hex_encoded_datamap>").await?;

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

5. Upload and download a file

These endpoints work on paths visible to the machine running antd.

cURL

curl -X POST http://localhost:8082/v1/files/public \
  -H "Content-Type: application/json" \
  -d '{"path":"/absolute/path/to/document.pdf"}'

curl -X POST http://localhost:8082/v1/files/public/get \
  -H "Content-Type: application/json" \
  -d '{"address":"<64_hex_address>","dest_path":"/absolute/path/to/downloaded-document.pdf"}'

Python

from antd import AntdClient

client = AntdClient()
result = client.file_put_public("/absolute/path/to/document.pdf")
client.file_get_public(result.address, "/absolute/path/to/downloaded-document.pdf")

print(result.address)

Node.js / TypeScript

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const result = await client.filePutPublic("/absolute/path/to/document.pdf");
  await client.fileGetPublic(result.address, "/absolute/path/to/downloaded-document.pdf");
  console.log(result.address);
}

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

Rust

use antd_client::{Client, DEFAULT_BASE_URL, PaymentMode};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(DEFAULT_BASE_URL);
    let result = client
        .file_put_public("/absolute/path/to/document.pdf", PaymentMode::Auto)
        .await?;
    client
        .file_get_public(&result.address, "/absolute/path/to/downloaded-document.pdf")
        .await?;

    println!("{}", result.address);
    Ok(())
}

Verify it worked

For raw data, compare the retrieved bytes to the original payload. For files, compare the downloaded output on disk with the original local source before you uploaded it.

Common errors

400 Bad Request: Check base64 encoding, address length, and local path values.

402 Payment Required: Fund the configured wallet or switch to a local devnet with test funds.

503 Service Unavailable: The daemon does not have wallet configuration. Restart it with AUTONOMI_WALLET_KEY or let ant dev start provision a local environment.

Next steps

• Store Data on the Network

• Prepare a Wallet for Uploads

• REST API

• SDK Overview

• Start the Local Daemon