> This is the Markdown version of the page. For the complete Lattice Developers documentation index, fetch https://developer.anduril.com/llms.txt. Append .md to any page URL for its clean Markdown.

# Download an object

> Getting data from Lattice using the SDK

In Lattice, an **object** is a data model that represents a single file or a piece of data. This page explains how to retrieve objects from Lattice.

## Before you begin

* To configure your app to upload objects, [set up](/guides/getting-started/set-up) your Lattice environment.
* See an overview of the [Object schema and the Object Store API](/guides/objects/overview) in Lattice.

## Download an object

In Lattice, an **object** is a data model that represents a single file or a piece of data. To download a specific binary object from Lattice
using its unique object path, do the following:

#### Get the object path

When using the [DownloadObject](/reference/rest/objects/get-object) API, you must specify
the object path of the object you want to download at runtime.

In the [previous](/guides/objects/upload) procedure,
you uploaded the following objects:

* Image: A `.jpg` image at the following path: `/api/v1/objects/cessna.jpg`.
  This image is a thumbnail of its associated track entity.
* CSV: A `.csv` file at the following path: `/api/v1/objects/manifest.csv`.
  This serves as metadata, in this case, a vessel manifest for the associated entity.
  Choose one, and note the object path.

#### Download the object

Run the following code in the directory where you'd like to download the object.
To download, use the [`GetObject`](/reference/rest/objects/get-object) operation.
Replace the following:

* <code class="code-highlight">**object\_path**</code>: the unique path of the object in Lattice.

```go title={"Go"} maxLines={25}
package main

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"os"

	Lattice "github.com/anduril/lattice-sdk-go/v5"
	"github.com/anduril/lattice-sdk-go/v5/client"
	"github.com/anduril/lattice-sdk-go/v5/option"
)

func main() {
	// Get environment variables
	latticeEndpoint := os.Getenv("LATTICE_ENDPOINT")
	environmentToken := os.Getenv("ENVIRONMENT_TOKEN")

	// Remove sandboxesToken from the following statements if you are not developing on Sandboxes
	sandboxesToken := os.Getenv("SANDBOXES_TOKEN")

	// Check required environment variables
	if latticeEndpoint == "" || environmentToken == "" || sandboxesToken == "" {
		fmt.Println("Missing required environment variables")
		os.Exit(1)
	}

	// Initialize headers for sandbox authorization
	headers := http.Header{}
	headers.Add("Anduril-Sandbox-Authorization", fmt.Sprintf("Bearer %s", sandboxesToken))

	// Create the client
	c := client.NewClient(
		option.WithToken(environmentToken),
		option.WithBaseURL(fmt.Sprintf("https://%s", latticeEndpoint)),
		option.WithHTTPHeader(headers),
	)
	// Set object path
	objectPath := "<OBJECT_PATH>"

	// Create context for the request
	ctx := context.Background()

	// Get the object
	response, err := c.Objects.GetObject(ctx, &Lattice.GetObjectRequest{ObjectPath: objectPath})
	if err != nil {
		fmt.Printf("Error getting object: %v\n", err)
		os.Exit(1)
	}
	// Create output file
	file, err := os.Create(objectPath)
	if err != nil {
		fmt.Printf("Error creating file: %v\n", err)
		os.Exit(1)
	}
	defer file.Close()

	// Copy data from response to file
	_, err = io.Copy(file, response)
	if err != nil {
		fmt.Printf("Error writing to file: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Object downloaded successfully. Object path: %s\n", objectPath)
}

```

```java title={"Java"} maxLines={25}
package org.example;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;

import com.anduril.Lattice;
public class Download {
    public static void main(String[] args) {
        // Get environment variables
        String endpoint = System.getenv("LATTICE_ENDPOINT");
        String environmentToken = System.getenv("ENVIRONMENT_TOKEN");
        String sandboxesToken = System.getenv("SANDBOXES_TOKEN");
        
        // Check required variables and ensure URL has https://
        if (endpoint == null || environmentToken == null || sandboxesToken == null) {
            System.err.println("Missing required environment variables");
            System.exit(1);
        }
        if (!endpoint.startsWith("https://")) endpoint = "https://" + endpoint;
        
        try {
            // Create Lattice client with Sandbox authentication
            Lattice client = Lattice.builder()
                .url(endpoint)
                .token(environmentToken)
                .addHeader("Anduril-Sandbox-Authorization", "Bearer " + sandboxesToken)
                .build();
            
            // Set the file path for downloaded file
            String objectPath = "<OBJECT_PATH>";
            
            // Create local file path with the original name and extension.
            String localFilePath = objectPath;
            File file = new File(localFilePath);
            
            try {
                // Download the object from Lattice
                InputStream response = client.objects().getObject(objectPath);
                
                // Save the downloaded object to file
                try (FileOutputStream outputStream = new FileOutputStream(file)) {
                    byte[] buffer = new byte[4096];
                    int bytesRead;
                    while ((bytesRead = response.read(buffer)) != -1) {
                        outputStream.write(buffer, 0, bytesRead);
                    }
                    System.out.println("Successfully downloaded " + objectPath + " to " + localFilePath);
                }
            } catch (Exception e) {
                System.err.println("Error downloading object: " + e.getMessage());
            }
        } catch (Exception e) {
            System.err.println("Error initializing client: " + e.getMessage());
        }
    }
}
```

```py title={"Python"} maxLines={25}
from anduril import Lattice
import os
import sys
import asyncio

lattice_endpoint = os.getenv('LATTICE_ENDPOINT')
environment_token = os.getenv('ENVIRONMENT_TOKEN')
# Remove sandboxes_token from the following statements if you are not developing on Sandboxes.
sandboxes_token = os.getenv('SANDBOXES_TOKEN')
if not environment_token or not lattice_endpoint or not sandboxes_token:
    print("Missing required environment variables.")
    sys.exit(1)
    
client = Lattice(
    base_url=f"https://{lattice_endpoint}",
    token=lambda: str(environment_token),
    # Remove the following if you are not developing on a Sandboxes.
    headers={ "anduril-sandbox-authorization": f"Bearer {sandboxes_token}" }
)
async def app(object_path):
    try:
        response = client.objects.get_object(
            object_path=object_path
        )
        chunks = [chunk for chunk in response]
        result = b''.join(chunks)
        print(f"Downloaded file: {result}")
    
    except asyncio.CancelledError:
        print(">>>Exiting...")
    except Exception as error:
        print(f"Exception: {error}")
if __name__ == "__main__":
    # Set the object path to the function to download the object.
    asyncio.run(app(object_path="<OBJECT_PATH>"))
```

```ts title={"Typescript"} maxLines={25}
import { LatticeClient } from "@anduril-industries/lattice-sdk";
import { writeFileSync } from 'fs';

const latticeEndpoint = process.env.LATTICE_ENDPOINT;
const environmentToken = process.env.ENVIRONMENT_TOKEN;

// Remove sandboxesToken from the following statements if you are not developing on Sandboxes.
const sandboxesToken = process.env.SANDBOXES_TOKEN;
if (!latticeEndpoint || !environmentToken || !sandboxesToken) {
    console.log('Missing required environment variables.');
    process.exit(1);
}
const client = new LatticeClient(
    {
        baseUrl: `https://${latticeEndpoint}`,
        token: environmentToken,
        // Remove the header if you are not developing on Sandboxes.
        headers: { "Anduril-Sandbox-Authorization": `Bearer ${sandboxesToken}` }
    }
);

async function App(objectPath: string) {
    try {
        const response = await client.objects.getObject({ objectPath });
        const data = new Uint8Array(await response.arrayBuffer());
        writeFileSync(objectPath, data);
        console.log(`Object downloaded successfully. Object path: ${objectPath}`);
    } catch (error) {
        if (error instanceof Error && error.name === 'AbortError') {
            console.log('Process interrupted. Exiting...');
            process.exit(0);
        } else {
            console.log(`Encountered the following error: ${error}`);
            process.exit(1);
        }
    }
}

// Replace objectPath with the path of the object you want to download from Lattice.
const objectPath = "<OBJECT_PATH>";
App(objectPath);
```

```rs title={"Rust"} startLine={35} maxLines={25}
use anduril_lattice_sdk::prelude::*;

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lattice_endpoint = env::var("LATTICE_ENDPOINT")
        .expect("LATTICE_ENDPOINT environment variable not set");
    let environment_token = env::var("ENVIRONMENT_TOKEN")
        .expect("ENVIRONMENT_TOKEN environment variable not set");
    // Remove sandboxes_token if you are not developing on Sandboxes.
    let sandboxes_token = env::var("SANDBOXES_TOKEN")
        .expect("SANDBOXES_TOKEN environment variable not set");

    if environment_token.is_empty() || lattice_endpoint.is_empty() || sandboxes_token.is_empty() {
        eprintln!("Missing required environment variables:");
        eprintln!("  LATTICE_ENDPOINT");
        eprintln!("  ENVIRONMENT_TOKEN");
        eprintln!("  SANDBOXES_TOKEN");
        std::process::exit(1);
    }

    let config = ClientConfig {
        base_url: format!("https://{}", lattice_endpoint),
        token: Some(environment_token),
        // Remove custom_headers if you are not developing on Sandboxes.
        custom_headers: HashMap::from([(
            "anduril-sandbox-authorization".to_string(),
            format!("Bearer {}", sandboxes_token),
        )]),
        ..Default::default()
    };
    let client = Lattice::new(config)?;

    // Set the object path to download.
    let object_path = "<OBJECT_PATH>";

    match client.objects.get_object(object_path, None).await {
        // get_object returns a streaming ByteStream. `collect` buffers the whole
        // object into a Vec<u8>; for large files, prefer `try_next` to process
        // chunks incrementally.
        Ok(stream) => match stream.collect().await {
            Ok(bytes) => println!("Downloaded file: {:?}", bytes),
            Err(e) => eprintln!("Exception: {}", e),
        },
        Err(e) => eprintln!("Exception: {}", e),
    }

    Ok(())
}

```

#### Verify the response

If successful, you'll see the following output:

```bash
INFO - HTTP Request: GET https://lattice-50802.env.sandboxes.developer.anduril.com/api/v1/objects/your_object_name "HTTP/1.1 200 OK"
```

## What's next?

* Learn more about the [Objects API](/reference/rest/objects/list-objects).

> Getting data from Lattice using the SDK