---
title: "Upload Object"
url: https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/stratus/upload-object/
description: "This page lists the Java SDK method to upload objects to a bucket."
last_updated: 2026-09-08T11:07:33Z
service: Cloud Scale
type: general
related_links:
  - name: "Stratus Component Help Documentation"
    url: /en/cloud-scale/help/stratus/introduction
  - name: "Upload Object Help Documentation"
    url: /en/cloud-scale/help/stratus/objects/upload-object/
  - name: "JavaScript SDK Documentation"
    url: /en/sdk/javascript/v1/cloudscale/stratus/upload-object/
  - name: "Python SDK"
    url: /en/sdk/python/v1/cloud-scale/stratus/upload-object/
  - name: "iOS SDK"
    url: /en/sdk/ios/v2/cloud-scale/stratus/upload-object/
  - name: "Android SDK"
    url: /en/sdk/android/v2/cloud-scale/stratus/upload-object/
  - name: "Flutter SDK"
    url: /en/sdk/flutter/v2/cloud-scale/stratus/upload-object/
  - name: "REST API"
    url: /en/api/code-reference/cloud-scale/stratus/get-all-buckets/#GetAllBuckets
---

# Upload Object

The SDK methods listed in this section will allow you to [upload objects](https://docs.catalyst.zoho.com/en/cloud-scale/help/stratus/objects/upload-object/) to the [bucket](https://docs.catalyst.zoho.com/en/cloud-scale/help/stratus/buckets/name-bucket/) in various manners. You can upload objects as a **string** or as a **stream**. The Bucket reference used in the below code snippet is the [component instance](https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/stratus/create-bucket-instance/).

If you do not have [Versioning](https://docs.catalyst.zoho.com/en/cloud-scale/help/stratus/stratus-config/general-settings/#versioning) enabled for your object, and if Stratus gets multiple write requests for the same object, the object will be continuously overwritten. The latest upload of the object will be the only object that is stored.

However, with Versioning enabled, each upload will be considered a version of the object, and all of them will be stored in the bucket, each with a unique `versionId`.

> **Note:** The following characters including space are not supported when you create a path or an object: double quote, both angular brackets, hashtag, backward slash and pipe symbol.

### Upload Object as a Stream

Using this SDK method, you can upload objects to a bucket as a stream. Store the stream in a variable and then pass that variable in the upload method.

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCPutObjectOptions;
import java.nio.file.Path;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import java.io.*;
```

```java
InputStream file =new FileInputStream("filePath");
Boolean res = bucket.putObject("sam/out/sample.txt", file);
System.out.println(res);
```

### Upload Object as a String

Using this SDK method, you can upload the object as a string. You will pass the object name, and the data to be stored in the object in string format in the upload method; `putObject()`

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCPutObjectOptions;
import java.nio.file.Path;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import java.io.*;
```

```java
Boolean res = bucket.putObject("sam/out/sample.txt", "content of the file");
System.out.println(res);
```

### Upload Object with Options

Using this SDK method, you can use the following options while you upload an object.

* `setOverwrite()`: This is an option you can use, if *Versioning* for your bucket is not enabled for your bucket. Without versioning, you need to use this option if you wish to overwrite a resource. The default value is '**false**'.

* `setTTL()`: This is an option you can use to set **Time-to-Live** (TTL) in seconds for an object. Value should be greater than or equal to **60 seconds**.

* `setMetaData()`: This is an option you can use to upload [meta details](https://docs.catalyst.zoho.com/en/cloud-scale/help/stratus/objects/introduction/#metadata) of the object that is being uploaded.

* `contentType`: This is an option you can provide, if you need to set the MIME type of the object.

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCPutObjectOptions;
import java.nio.file.Path;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import java.util.Map;
import java.io.*;
```

```java
ZCPutObjectOptions options = ZCPutObjectOptions.getInstance();
options.setTTL("1000");
options.setOverwrite("true");
Map<String, String> metaData = new HashMap<String, String>();
metaData.put("author", "John");
options.setMetaData(metaData);
InputStream file = new FileInputStream("filePath");
Boolean res = bucket.putObject("sam/out/sample.txt", file, options);
System.out.println(res);
```

### Upload Object With Extract Option

When you upload a zipped object using the `putZipObject()` SDK method, the objects present in the zip will be extracted, and uploaded.

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.ZCBucket;
import com.zc.component.stratus.ZCStratus;
import com.zc.component.stratus.beans.ZCPutObjectOptions;
```

```java
ZCStratus stratus = ZCStratus.getInstance();
ZCBucket bucket = stratus.bucketInstance("sam1");
ZCPutObjectOptions options = ZCPutObjectOptions.getInstance();
options.setOverwrite("true");
InputStream stream = new FileInputStream("file_path");
JSONObject object = bucket.putZipObject("sam.zip", stream, options);

```

This SDK method will return the value of a `taskId`. You can use this value to find out the status of the extraction using this [SDK method](https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/stratus/extract-zipped-object/#get-zip-extraction-status). 

**Example Response**

```json
{ 'task_id': '1234263749' }
```

### Upload an Object Using Multipart Operations

When the Object that you need to upload is too large to upload, you can perform a multipart operation. The multipart operation will split the object into multiple parts and perform a quicker upload. In this SDK section, we are going to go over all the SDK methods that are available to perform multipart upload of objects in Stratus.

#### Initiate Multipart Upload

Using the following SDK method, we are going to return a `uploadId`. This ID will allow us to upload multiple pats of the object.

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCInitiateMultipartUpload;
```

```java
ZCInitiateMultipartUpload multipart = bucket.initiateMultipartUpload("sam/out/sample.txt");
```

#### Perform Multipart Upload for Parts of the Object

In the following SDK method, we are going to perform uploads of the individual parts of the object. Each part will have a distinct `part_number` ranging anywhere between **1 and 1000**. While this represents the ordering of the parts, these parts will not necessarily be uploaded in sequence. These parts will be combined in sequence once the upload of all the parts of the objects is complete.

**Parameters Used**

<table class="content-table">
	<thead>
		<tr>
			<th class="w20p">Parameter Name</th>
			<th class="w20p">Data Type</th>
      <th class="w60p">Definition</th>
		</tr>
	</thead>
	<tbody>
		<tr>
			<td>`key`</td>
			<td>**String**</td>
			<td>A **Mandatory** parameter. Will hold the name of the object.</td>
		</tr>
		<tr>
			<td>`uploadId`</td>
			<td>**String**</td>
			<td>A **Mandatory** parameter. This value is returned in the Initiate Multipart Upload method.</td>
		</tr>
		<tr>
			<td>`part`</td>
			<td>**InputStream**</td>
			<td>A **Mandatory** parameter. Will hold the data of the object part.</td>
		</tr>
		<tr>
			<td>`partNumber`</td>
			<td>**Int**</td>
			<td>A **Mandatory** parameter. Will have the ordering of the parts that are being uploaded.</td>
		</tr>
	</tbody>
</table>

#### Sample Code Snippet 

**Package Imports**

```java
import java.io.*;
```

```java
int partNumber = 1;
InputStream part = new FileInputStream("filePath");
Boolean res = bucket.uploadPart("sam/out/sample.txt", "uploadId", part, partNumber);
System.out.println(res);
```

#### Get Multipart Upload Summary 

The following SDK method can be used to obtain an operational summary of all the uploaded parts. To view the summary, we pass the `uploadId` to the `getMultipartUploadSummary()` method.

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCMultipartObjectSummary;
```

```java
ZCMultipartObjectSummary summaryRes = bucket.getMultipartUploadSummary("sam/out/sample.txt", "uploadId");
// accessing uploaded parts
System.out.println("Object Name:" + summaryRes.getKey());
System.out.println("Upload Id:" + summaryRes.getUploadId());
System.out.println("Status:" + summaryRes.getStatus());
System.out.println(summaryRes.getParts().get(0).getUploadedAt());
System.out.println(summaryRes.getParts().get(0).getPartNumber());

```

#### Complete Multipart Upload Operation

The following method allows us to terminate the multipart process once all the parts have been successfully uploaded. To complete the process we will pass the `uploadId` to the `completeMultipartUpload()` method.

```java
Boolean completeRes = bucket.completeMultipartUpload("sam/out/sample.txt", "uploadId");
System.out.println(completeRes);
```

#### Example Snippet Illustring Implementation of Multipart Operations

#### Sample Code Snippet 

**Package Imports**

```java
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.catalyst.advanced.CatalystAdvancedIOHandler;
import com.zc.component.stratus.ZCBucket;
import com.zc.component.stratus.ZCStratus;
import com.zc.component.stratus.beans.ZCInitiateMultipartUpload;
import com.zc.exception.ZCServerException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.ByteArrayInputStream;
```

```java
public class MultipartUpload implements CatalystAdvancedIOHandler {
    private static final Logger LOGGER = Logger.getLogger(Sample.class.getName());
    @Override
    public void runner(HttpServletRequest request, HttpServletResponse response) throws Exception {
        try {
            switch (request.getRequestURI()) {
                case "/": {
                    ZCStratus stratus = ZCStratus.getInstance();
                    // get bucket instance
                    ZCBucket bucket = stratus.bucketInstance("sample");
                    // multipart upload
                    String key = "sample.mp4";
InputStream file = new FileInputStream(
                            "/users/sam/sample.mp4");
				ZCInitiateMultipartUpload initiateUploadResponse = bucket.initiateMultipartUpload(key);
                    String uploadId = initiateUploadResponse.getUploadId();
                    System.out.println("Multipart upload initiated. Upload ID: " + uploadId);
                    // File size and part size (50 MB minimum)
                    int partSize = 50 * 1024 * 1024; // 50 MB
                    long fileSize = file.available();
                    double result = (double) fileSize / partSize;
                    int noOfParts = (int) Math.ceil(result);
                    // Upload parts in parallel
                    List&lt;CompletableFuture&lt;Void&gt;&gt; uploadedParts = new ArrayList&lt;&gt;();
                    ExecutorService executor = Executors.newFixedThreadPool(4);
                    int partNumber = 1;
                    while (noOfParts &gt;= partNumber) {
                        int currentPartNumber = partNumber;
                        byte[] buffer = new byte[partSize];
                        file.read(buffer);
                        InputStream fileData = new ByteArrayInputStream(buffer);
                        uploadedParts.add(CompletableFuture.runAsync(() -&gt; {
                            try {
                                bucket.uploadPart(key, uploadId, fileData, currentPartNumber);
                                LOGGER.log(Level.INFO, "Part {0} Uploaded", currentPartNumber);
                            } catch (Exception e) {
                                throw new RuntimeException(e);
                            }
                        }, executor));
                        partNumber++;
                    }
                    CompletableFuture&lt;Void&gt; isUploaded = CompletableFuture
                            .allOf(uploadedParts.toArray(new CompletableFuture[0]));
                    try {
                        isUploaded.get();
                    } catch (Exception e) {
                        throw new ZCServerException("Error while uploading the object", e);
                    }
                    Boolean completeRes = bucket.completeMultipartUpload(key, uploadId);
                    if (completeRes) {
                        LOGGER.log(Level.INFO, "Upload Completed");
                    }
                }
                default: {
                    response.setStatus(404);
                    response.getWriter().write("You might find the page you are looking for at \"/\" path");
                }
            }
        } catch (Exception e) {
            if (e instanceof ZCServerException) {
                int statusCode = ((ZCServerException) e).getStatus();
                System.out.println("HTTP status code: " + statusCode);
            }
            LOGGER.log(Level.SEVERE, "Exception in Sample", e);
        }
    }
}
```

### Upload an Object Using Transfer Manager

#### Create Transfer Manager Instance

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.transfer.ZCTransferManager;
```

```java
ZCTransferManager transferManager= ZCTransferManager.getInstance(bucket);
```

#### Multipart Upload

**Create Multipart Upload Instance**

The following SDK method will create a multipart instance by initiating multipart upload.

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCMultipartUpload;
```

```java
ZCMultipartUpload multipart = transferManager.createMultipartInstance("sam/out/sample.txt");
```

If you are required to create an instance for an already initialized multipart upload operation, then copy and use the code snippet given below

```java
ZCMultipartUpload multipart = transferManager.createMultipartInstance("sam/out/sample.txt", "uploadId");
```

#### Upload Part

In the following SDK method we are going to be using the `multipart` instance we initialized in the *Create Multipart Upload Instance* section.

#### Sample Code Snippet 

**Package Imports**

```java
import java.io.InputStream;
```

```java
int partNumber = 1;
InputStream part = new FileInputStream("filePath");
Boolean uploadRes = multipart.uploadPart(part, partNumber);
System.out.println(uploadRes);
```

#### Upload Summary

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.beans.ZCMultipartObjectSummary;
```

```java
ZCMultipartObjectSummary summaryRes = multipart.getUploadSummary();
// accessing uploaded parts
System.out.println("Object Name:" + summaryRes.getKey());
System.out.println("Upload Id:" + summaryRes.getUploadId());
System.out.println("Status:" + summaryRes.getStatus());
System.out.println(summaryRes.getParts().get(0).getUploadedAt());
System.out.println(summaryRes.getParts().get(0).getPartNumber());
System.out.println(summaryRes.getParts().get(0).getSize());
```

#### Complete Upload

```java
Boolean completeRes = multipart.completeUpload();
System.out.println(completeRes);
```

#### Upload Object Using Wrapper

The following SDK method acts as a wrapper, where the entire multipart upload operation is carried out without employing multiple steps. Using this method, the object is split into multiple parts, uploaded to the bucket in multiple parts, and then combined once all the parts are uploaded.

```java
import java.io.InputStream;
import com.zc.component.stratus.beans.ZCMultipartObjectSummary;
```

```java
InputStream file =new FileInputStream("filePath");
int partSize = 50;
ZCMultipartObjectSummary res = transferManager.putObjectAsParts("objetName", file, partSize);
```

> **Note:** For object's that are larger than **2GB**, we would recommend that you use the individual SDK methods to carry out the multipart upload operation successfully.

### Generate Presigned URL to Upload an Object

Presigned URLs are secure URLs that authenticated users can share to their non-authenticated users. This URL will provide non-authenticated users with temporary authorization to access objects. The Bucket reference used in the below code snippet is the [component instance](https://docs.catalyst.zoho.com/en/sdk/java/v1/cloud-scale/stratus/create-bucket-instance/).

> **Info:** To use this SDK method, you need intialize it with **Admin** scope. You can learn more about this requirement from this [section](https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/overview/#initialize-sdk-with-scopes)

**Parameters Used**

<table class="content-table">
	<thead>
		<tr>
			<th class="w20p">Parameter Name</th>
			<th class="w20p">Data Type</th>
      <th class="w60p">Definition</th>
		</tr>
	</thead>
	<tbody>
		<tr>
			<td>`key`</td>
			<td>**String**</td>
			<td>A **Mandatory** parameter. Will hold the complete name of the object along with it's [path](https://docs.catalyst.zoho.com/en/cloud-scale/help/stratus/objects/introduction/#path).</td>
		</tr>
		<tr>
			<td>`URL_ACTION`</td>
			<td>**Enum**</td>
			<td>A **Mandatory** parameter. This is the parameter that will allow you to generate a presigned URL for an upload action.
        <ul>
          <li>`URL_ACTION.PUT`: To upload an object</li>
        </ul>
      </td>
    </tr>
    <tr>
      <td>`expiry`</td>
      <td>**String**</td>
      <td>This is an **Optional** parameter. The URL validity time in seconds.
        <ul>
          <li>Default value: **3600 seconds**</li>
          <li>Minimum value: **30 seconds**</li>
          <li>Maximum value: **7 days**</li>
        </ul>
      </td>
    </tr>
    <tr>
      <td>`activeFrom`</td>
      <td>**String**</td>
      <td>This is an **Optional** parameter. This param will contain the time after which the URL is valid. Maximum value is **7 days**. URLs are made active as soon as they are generated by default.</td>
		</tr>
	</tbody>
</table>

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.enums.URL_ACTION;
import org.json.simple.JSONObject;
```

```java
JSONObject res = bucket.generatePreSignedUrl("sam/out/sample.txt", URL_ACTION.PUT);
System.out.println(res.get("signature"));

```

### Generate Presigned URL With Expiry and Active Time

#### Sample Code Snippet 

**Package Imports**

```java
import com.zc.component.stratus.enums.URL_ACTION;
import org.json.simple.JSONObject;
```

```java
JSONObject res = bucket.generatePreSignedUrl("object_name",URL_ACTION.GET, "expiry_in","active_from");
System.out.println(res.get("signature"));

```

**Example Response for Generating a Presigned URL for Upload**

```json
{
  "signature": "https://sadi-development.zohostratus.com/_signed/sam.txt?organizationId=96862383&stsCredential=96858154-96862383&stsDate=1747904989454&stsExpiresAfter=300&stsSignedHeaders=host&stsSignature=UPyH5A4AdAaCpw6S6jVhKFSxg3B0B0p619YN0cAIn4c",
  "expiry_in_seconds": "100",
  "active_from": "1726492859577"
}
```

**Example Snippet Illustrating Usage of Presigned URL to Upload an Object**

**Package Imports**

```java
import okhttp3.*;
import java.io.File;
import java.io.IOException;
```

```java
public class BinaryFileUpload {
    public static void main(String[] args) throws IOException {
        //  Create an OkHttpClient instance for making HTTP requests
        OkHttpClient client = new OkHttpClient();
        //  Specify the file to upload. Replace "file_path" with actual file location
        File file = new File("file_path");
        //  Create the request body with binary content (octet-stream)
        RequestBody requestBody = RequestBody.create(
                MediaType.parse("application/octet-stream"), // Use a specific MIME type if known
                file
        );
        // ️ Build the PUT request with the pre-signed URL
        Request request = new Request.Builder()
                .url("https://sadi-development.zohostratus.com/_signed/sam.txt?organizationId=96862383&stsCredential=96858154-96862383&stsDate=1747904989454&stsExpiresAfter=300&stsSignedHeaders=host&stsSignature=UPyH5A4AdAaCpw6S6jVhKFSxg3B0B0p619YN0cAIn4c") // Replace with a actual URL
                .put(requestBody) //  PUT request to upload file
                .build();
        //  Execute the request and handle the response
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println("Object uploaded successfully");
            } else {
                // Print error if upload fails
                System.err.println("Error: " + response.code() + " - " + response.body().string());
            }
        }
    }
}
```