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, files, and directories 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

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

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

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);
});

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 result = client.data_put_public(b"Hello, Autonomi!", None).await?;

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

2. Retrieve public data

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

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);
});

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 instead of a public address.

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

curl -X POST http://localhost:8082/v1/data/private \
  -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"
}

import { createClient } from "antd";

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

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 result = client.data_put_private(b"Secret message", None).await?;

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

In the Python, Node.js / TypeScript, and Rust SDKs, the returned private data_map is surfaced through PutResult.address.

4. Retrieve private data

curl "http://localhost:8082/v1/data/private?data_map=<hex_encoded_datamap>"

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const data = await client.dataGetPrivate("<hex_encoded_datamap>");
  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_private("<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 -X POST http://localhost:8082/v1/files/upload/public \
  -H "Content-Type: application/json" \
  -d '{"path":"/absolute/path/to/document.pdf"}'

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

from antd import AntdClient

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

print(result.address)

import { createClient } from "antd";

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

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 result = client
        .file_upload_public("/absolute/path/to/document.pdf", None)
        .await?;
    client
        .file_download_public(&result.address, "/absolute/path/to/downloaded-document.pdf")
        .await?;

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

6. Upload and download a directory

curl -X POST http://localhost:8082/v1/dirs/upload/public \
  -H "Content-Type: application/json" \
  -d '{"path":"/absolute/path/to/my-folder"}'

curl -X POST http://localhost:8082/v1/dirs/download/public \
  -H "Content-Type: application/json" \
  -d '{"address":"<64_hex_address>","dest_path":"/absolute/path/to/output-folder"}'

from antd import AntdClient

client = AntdClient()
result = client.dir_upload_public("/absolute/path/to/my-folder")
client.dir_download_public(result.address, "/absolute/path/to/output-folder")

print(result.address)

import { createClient } from "antd";

async function main() {
  const client = createClient();
  const result = await client.dirUploadPublic("/absolute/path/to/my-folder");
  await client.dirDownloadPublic(result.address, "/absolute/path/to/output-folder");
  console.log(result.address);
}

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 result = client
        .dir_upload_public("/absolute/path/to/my-folder", None)
        .await?;
    client
        .dir_download_public(&result.address, "/absolute/path/to/output-folder")
        .await?;

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

Verify it worked

For raw data, compare the retrieved bytes to the original payload. For files and directories, 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

PreviousHow-To Guides NextUse the Daemon as a Local Service

Last updated 1 day ago

hashtagPrerequisites

hashtagSteps

hashtag1. Store public data

hashtag2. Retrieve public data

hashtag3. Store private data

hashtag4. Retrieve private data

hashtag5. Upload and download a file

hashtag6. Upload and download a directory

hashtagVerify it worked

hashtagCommon errors

hashtagNext steps