Upload Object

Updated at：2025-11-03

In BOS, the fundamental data unit for user operations is the object. Although there is no limit to the number of objects in a bucket, each object can store a maximum of 5 TB of data.

An object consists of three components: a key, metadata, and data. Specifically:

Key is the name of the object;
Meta is the user’s description of the object, consisting of a series of Name-Value pairs;
The data component represents the content of the object.

The BOS JavaScript SDK provides a rich set of file upload APIs, and files can be uploaded in the following ways:

Simple upload
Append upload
Multipart upload
Resumable upload

The naming rules for objects are as follows:

Use UTF-8 for encoding.
The length must range from 1 to 1023 bytes.
The first character cannot be '/', and the '@' character is not allowed, as '@' is reserved for use in image processing APIs.

Simple upload

In simple upload scenarios, the JS SDK supports uploading objects in the form of data streams, strings, specified files (only supported in the Node.js environment), and blob objects (only supported in the browser environment). They correspond to the putObject, putObjectFromString, putObjectFromFile, and putObjectFromBlob methods respectively.

Basic workflow
1. Create a BosClient instance.
2. Call methods related to putObject()

Example code

                JavaScript
                
            

                function done(response) {
 // Upload completed
}
function fail(fail) {
 // Upload failed
}
            

// Upload in buffer form var buffer = new Buffer('hello world'); client.putObject(bucket, object, buffer) .then(done) .catch(fail);

Plain Text

1// Upload in string form
2client.putObjectFromString(bucket, object, 'hello world')
3  .then(done)
4  .catch(fail);
5
6 // Upload in file form, only supported in Node.js environment
7client.putObjectFromFile(bucket, object, <path-to-file>)
8  .then(done)
9  .catch(fail);
10
11 // Upload in blob object form, only supported in browser environment
12 client.putObjectFromBlob(bucket, object, <blob object>)
13  .then(done)
14  .catch(fail);
15```
16 > **Note:** Objects are uploaded to BOS in the form of files. putObject function supports uploading objects with a size not exceeding 5 GB. After the putObject request is processed successfully, BOS will return the ETag of the object in the Header as the file identifier.

Append upload

Objects created using the simple upload method described above are all of a standard type and do not support append writes. This limitation can be inconvenient in scenarios where frequent data overwriting occurs, such as log files, video surveillance, and live video streaming.

To address this, Baidu AI Cloud Object Storage (BOS) specifically supports the AppendObject method, which allows files to be uploaded in an append-write fashion. Objects created through the AppendObject operation are categorized as Appendable Objects, enabling data to be appended to them. The size limit for AppendObject files is 0–5 GB.

                JavaScript
                
            

                let bucketName = "yourbucket";
let appendKey = "appendObjectKey";
 // When uploading for the first time, set offset to null
client.appendObjectFromString(bucketName,appendKey,"firstContent",null)
.then(function(response){
 // Get the offset from the response header
  var offset = + response.http_headers['x-bce-next-append-offset'];
 // When appending upload for the second time, pass in the offset obtained above
  client.appendObjectFromString(bucketName, appendKey, "appendContent", offset);
});
            

Multipart upload

In addition to using the putObject() method for file uploads to BOS, BOS also supports another upload mode called Multipart Upload. This mode can be used in scenarios such as:

When resumable uploads are required.
When uploading files larger than 5GB.
When the connection to the BOS server is frequently interrupted due to unstable network conditions.
Enable streaming file uploads.
The file size cannot be determined before uploading.

Multipart upload is slightly more complex than direct upload. Multipart upload is divided into three stages:

Initiate upload (initiateMultipartUpload)
Upload parts (uploadPartFromBlob)
Complete upload (completeMultipartUpload)

Browser-side code example

Divide the file in parts

                JavaScript
                
            

                let options = {
 'Content-Type': 'application/json', // Add http header
 'Cache-Control': 'public, max-age=31536000', // Specify cache directives
 'Content-Disposition': 'attachment; filename="example.jpg"', // Indicate how the response content should be displayed
 'x-bce-meta-foo1': 'bar1', // Add custom meta information
 'x-bce-meta-foo2': 'bar2', // Add custom meta information
 'x-bce-meta-foo3': 'bar3', // Add custom meta information
};
 let PART_SIZE = 5 * 1024 * 1024; // Specify the part size
function getTasks(file, uploadId, bucketName, key) {
    let leftSize = file.size;
    let offset = 0;
    let partNumber = 1;
    let tasks = [];
    while (leftSize > 0) {
        let partSize = Math.min(leftSize, PART_SIZE);
        tasks.push({
            file: file,
            uploadId: uploadId,
            bucketName: bucketName,
            key: key,
            partNumber: partNumber,
            partSize: partSize,
            start: offset,
            stop: offset + partSize - 1
        });
        leftSize -= partSize;
        offset += partSize;
        partNumber += 1;
    }
    return tasks;
}
            

Handle the upload logic for each part

                JavaScript
                
            

                function uploadPartFile(state, client) {
    return function(task, callback) {
        let blob = task.file.slice(task.start, task.stop + 1);
        client.uploadPartFromBlob(task.bucketName, task.key, task.uploadId, task.partNumber, task.partSize, blob)
            .then(function(res) {
                ++state.loaded;
                callback(null, res);
            })
            .catch(function(err) {
                callback(err);
            });
    };
}
            

Initialize uploadID, start uploading parts, and complete the upload

                JavaScript
                
            

                let uploadId;
client.initiateMultipartUpload(bucket, key, options)
    .then(function(response) {
 uploadId = response.body.uploadId; // Start the upload and get the server-generated uploadId
        let deferred = sdk.Q.defer();
        let tasks = getTasks(blob, uploadId, bucket, key);
        let state = {
            lengthComputable: true,
            loaded: 0,
            total: tasks.length
        };
 // To manage multipart uploads, the async library (https://github.com/caolan/async) is used for asynchronous processing
 let THREADS = 2; // Number of parts uploaded simultaneously
        async.mapLimit(tasks, THREADS, uploadPartFile(state, client), function(err, results) {
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(results);
            }
        });
        return deferred.promise;
    })
    .then(function(allResponse) {
        let partList = [];
        allResponse.forEach(function(response, index) {
 // Generate the part list
            partList.push({
                partNumber: index + 1,
                eTag: response.http_headers.etag
            });
        });
 return client.completeMultipartUpload(bucket, key, uploadId, partList); // Complete the upload
    })
    .then(function (res) {
 // Upload completed
    })
    .catch(function (err) {
 // Upload failed, add your code
        console.error(err);
    });
            

Node.js-side code example

Divide the file in parts, initialize UploadID, and upload parts

                JavaScript
                
            

                let options = {
 'Content-Type': 'application/json', // Add http header
 'Cache-Control': 'public, max-age=31536000', // Specify cache directives
 'Content-Disposition': 'attachment; filename="example.jpg"', // Indicate how the response content should be displayed
 'x-bce-meta-foo1': 'bar1', // Add custom meta information
 'x-bce-meta-foo2': 'bar2', // Add custom meta information
 'x-bce-meta-foo3': 'bar3', // Add custom meta information
};
 let PART_SIZE = 5 * 1024 * 1024; // Specify the part size
let uploadId;
client.initiateMultipartUpload(bucket, key, options)
    .then(function(response) {
 uploadId = response.body.uploadId; // Start the upload and get the server-generated uploadId
        let deferred = sdk.Q.defer();
        let blob = {
 // Use the fs file library to get the file size
            size: fs.statSync(localFileName).size,
            filename: localFileName
        }
        let tasks = getTasks(blob, uploadId, bucket, key);
        let state = {
            lengthComputable: true,
            loaded: 0,
            total: tasks.length
        };
 // To manage multipart uploads, the async library (https://github.com/caolan/async) is used for asynchronous processing
 let THREADS = 2; // Number of parts uploaded simultaneously
        async.mapLimit(tasks, THREADS, uploadPartFile(state, client), function(err, results) {
            if (err) {
                deferred.reject(err);
            } else {
                deferred.resolve(results);
            }
        });
        return deferred.promise;
    })
    .then(function(allResponse) {
        let partList = [];
        allResponse.forEach(function(response, index) {
 // Generate the part list
            partList.push({
                partNumber: index + 1,
                eTag: response.http_headers.etag
            });
        });
 return client.completeMultipartUpload(bucket, key, uploadId, partList); // Complete the upload
    })
    .then(function (res) {
 // Upload completed
    })
    .catch(function (err) {
 // Upload failed, add your code
        console.error(err);
    });
function getTasks(file, uploadId, bucketName, key) {
    let leftSize = file.size;
    let offset = 0;
    let partNumber = 1;
    let tasks = [];
    while (leftSize > 0) {
        let partSize = Math.min(leftSize, PART_SIZE);
        tasks.push({
            file: file.filename,
            uploadId: uploadId,
            bucketName: bucketName,
            key: key,
            partNumber: partNumber,
            partSize: partSize,
            start: offset,
            stop: offset + partSize - 1
        });
        leftSize -= partSize;
        offset += partSize;
        partNumber += 1;
    }
    return tasks;
}
function uploadPartFile(state, client) {
    return function(task, callback) {
        console.log("task: ", task)
        return client.uploadPartFromFile(task.bucketName, task.key, task.uploadId, task.partNumber, task.partSize, task.file , task.start)
            .then(function(res) {
                ++state.loaded;
                console.log("ok")
                callback(null, res);
            })
            .catch(function(err) {
                console.log("bad")
                callback(err);
            });
    };
}
            

Cancel multipart upload event

Users can cancel multipart uploads by using the abortMultipartUpload method.

                JavaScript
                
                client.abortMultipartUpload(<BucketName>, <Objectkey>, <UploadID>);

Retrieve unfinished multipart upload event

Users can use the listMultipartUploads method to retrieve ongoing multipart upload events within a bucket.

                JavaScript
                
            

                client.listMultipartUploads(<bucketName>)
    .then(function (response) {
 // Traverse all upload events
        for (var i = 0; i < response.body.multipartUploads.length; i++) {
            console.log(response.body.multipartUploads[i].uploadId);
        }
    });
            

Get all uploaded part information

Users can use the listParts method to retrieve all parts uploaded during an upload event.

                JavaScript
                
            

                client.listParts(<bucketName>, <key>, <uploadId>)
    .then(function (response) {
 // Traverse all upload events
        for (var i = 0; i < response.body.parts.length; i++) {
            console.log(response.body.parts[i].partNumber);
        }
    });
            

Resumable upload

When users upload large files to BOS, network instability or program crashes can cause the entire upload to fail, invalidating any parts uploaded before the failure. Users must restart the upload process, which wastes resources and often leads to repeated failures in unstable network conditions. To address this scenario, BOS offers resumable upload functionality, leveraging multipart upload capabilities. This method splits the file into multiple parts, uploads these parts separately, and once all parts are uploaded, combines them into a complete object.

putSuperObject

Supported in version 1.0.1-beta.2 and above

The JavaScript SDK provides the putSuperObject method, which is a high-level encapsulation of APIs related to multipart upload. It supports functions such as pausing, resuming, canceling upload tasks, setting the number of concurrent shards, and retrying on failure.

Request headers

No special request headers beyond common headers.

Initialization parameters

Parameter name	Description	Types	Required	Default value	Example value
bucketName	Bucket name	`string`	Yes	-	`"bucket001"`
objectName	Object name after upload	`string`	Yes	-	`"file001"`
data	Upload data: when the type is string, it represents the file path; Buffer and Blob objects are also supported	`string` \| `Buffer` \| `Blob`	Yes	-	-
StorageClass	File storage class	`"STANDARD"` \| `"STANDARD_IA"` \| `"COLD"` \| `"ARCHIVE"` \| `"MAZ_STANDARD"` \| `"MAZ_STANDARD_IA"`	No	`"STANDARD"`	`"STANDARD"`
chunkSize	Default size of uploaded file shards, in bytes	`number`	No	5 * 1024 ** 2（5MB）	`1048576`
partConcurrency	Number of concurrent shards	number	No	5	5
ContentLength	File size, in bytes, not required; it will be automatically calculated internally	`string`	No	-	`1048576`
ContentType	File media type, not required; it will be automatically generated based on the objectName field internally	`string`	No	-	`"application/x-gtar"`
uploadId	Multipart upload task ID, not required; it needs to be passed in when resuming a task from a breakpoint	`string`	No	-	`"a44cc9bab11cbd156984767aad637851"`
onProgress	Upload progress callback function	`ProgressCallback`	No	-	-
onStateChange	Task status change callback function	`StateChangeCallback`	No	-	-

ProgressCallback

                Typescript
                
            

                type ProgressCallback = (
 /* Current upload speed */
    speed: string,
 /* Upload progress, retaining 4 decimal places */
    progress: number,
 /* Upload progress - percentage */
    percent: string,
 /* Number of bytes uploaded */
    uploadedBytes: number,
 /* Total bytes of the file */
    totalBytes
) => void
            

StateChangeCallback

                Typescript
                
            

                type StateChangeCallback = (
 /* Status */
    state: string,
 /* If the upload fails, the failure message will be passed; if the upload is successful, the address after upload will be returned */
    options: {
        message: string;
        data: Record<string, any> | null
    }
) => void;
            

Status

"inited": Task initialization completed
"running": Task queue is running
"paused": Task queue paused
"completed": Task completed, upload ended
"cancelled": Task cancelled, upload ended
"failed": Task abnormal, upload ended

Node.js-side code example

                Javascript
                
            

                const sdk = require('@baiducloud/sdk');
const client = new sdk.BosClient({
  endpoint: 'http://bj.bcebos.com',
  credentials: {
    ak: "<Your Access Key>",
    sk: "<Your Secret Key>"
  }
});
 // Bucket name
const bucketName = "<Your Bucket Name>";
 // Name of the file after upload
const objectName = 'demo.tgz';
 // Local file path
const data = '/Mock/path/to/local/file/demo.tgz';
 // Initialize upload task
const SuperUploadTask = client.putSuperObject({
 // Bucket name
    bucketName,
 // Object name after upload
    objectName,
 // Upload data: when the type is string, it represents the file path
    data,
 // Number of concurrent shards
    partConcurrency: 2,
 // Upload progress callback function
    onProgress: (options) => {
        const {speed, progress, percent, uploadedBytes, totalBytes} = options;
        console.log(options);
    },
 // Status change callback function
    onStateChange: (state, data) => {
        if (state === 'completed') {
 console.log('Upload successful');
        } else if (state === 'failed') {
 console.error('Upload failed, reason:' + data.message);
        } else if (state === 'cancelled') {
 console.log('Upload task cancelled');
        } else if (state === 'inited') {
 console.log('Upload task initialization completed');
        } else if (state === 'running') {
 console.log('Upload task starts running...');
        } else if (state === 'paused') {
 console.log('Upload task paused');
        }
    }
});
 // Start upload task
const tasks = SuperUploadTask.start();
 console.log('Split tasks: ', tasks);
 // Pause upload task
setTimeout(() => {
    SuperUploadTask.pause();
}, 5000);
 // Resume upload task
setTimeout(() => {
    SuperUploadTask.resume();
}, 15000);
 // Cancel upload task
setTimeout(async () => {
    const result = SuperUploadTask.cancel();
 console.log(result ? 'Task cancelled successfully' : 'Failed to cancel task');
}, 25000);
            

Browser-side code example

                HTML
                
            

                <html>
  <head>
    <meta charset="utf-8" />
 <title>SuperUpload Test</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/amis/6.2.2/sdk.min.css" integrity="sha512-9yikVhRqNeq1rypIzAFKR8CA2uG8V5gYppoDKK4xx+7eoLXJsEm+f9QN0++xqHvrOxxvb93uiipgYk9uEW7RlA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/amis/6.2.2/cxd.min.css" integrity="sha512-9yikVhRqNeq1rypIzAFKR8CA2uG8V5gYppoDKK4xx+7eoLXJsEm+f9QN0++xqHvrOxxvb93uiipgYk9uEW7RlA==" crossorigin="anonymous" referrerpolicy="no-referrer" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/simple-notify@1.0.4/dist/simple-notify.css" />
  </head>
  <body>
      <div id="root"></div>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js" integrity="sha512-v2CJ7UaYy4JwqLDIrZUI/4hqeoQieOmAZNXBeQyjo21dadnwR+8ZaIJVT8EE2iyI61OV8e6M8PP2/4hpQINQ/g==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
      <script src="https://cdn.jsdelivr.net/npm/simple-notify@1.0.4/dist/simple-notify.min.js"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/amis/6.2.2/sdk.min.js" integrity="sha512-BpMIHWCtAUDARuH/qnGH6eBxoOv4l0i4Y9/9f6vnGVDNnPqbWCZoPgk3/KvY6NuOb6cAPFmqVN1R2sXz7Z3VcQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
      <script src="https://bce.bdstatic.com/lib/@baiducloud/sdk/1.0.1-beta.2/baidubce-sdk.bundle.min.js" ></script>
      <script>
        (async function () {
 // Instantiate BOS SDK
            const client = new window.baidubce.sdk.BosClient({
              endpoint: 'http://bj.bcebos.com',
              credentials: {
                ak: "<Your Access Key>",
                sk: "<Your Secret Key>"
              }
            });
 // Instantiate BOS SDK
            const bucketName = '<Your Bucket Name>';
 // Upload task instance
            let SuperUpload;
 // Progress information
            let p1 = 0;
            
 // Message popup
            function pushNotify({status, title, text}) {
              new Notify({
                status: status || 'success',
                title: title,
                text: text,
                distance: 200,
                position: 'x-center'
              });
            }
 // Get task instance
            function getInstance() {
              if (SuperUpload) {
 pushNotify({title: 'Get instance information', text: 'Instance information got successfully'});
              } else {
 pushNotify({status: 'error', title: 'Get instance information', text: 'Failed to get instance information'});
              }
            }
            
            async function start() {
              const files = $('#file')?.[0]?.files;
    
              if (!files || files.length === 0) {
 pushNotify({status: 'error', title: 'Upload', text: 'Please select a file first'});
                return;
              }
    
              const file = files[0];
              let reader = new FileReader();
              let rs = reader.readAsArrayBuffer(file);
              let blob = null;
    
 // Read the file as a Blob object
              reader.onload = async e => {
                if (typeof e.target.result === 'object') {
                  blob = new Blob([e.target.result]);
                } else {
                  blob = e.target.result;
                }
    
                SuperUpload = client.putSuperObject({
                  bucketName,
                  objectName: file.name,
                  ContentLength: file.size,
                  ContentType: file.type,
                  data: blob,
                  partConcurrency: 2,
                  onProgress: options => {
                    const {speed, progress, uploadedBytes, totalBytes} = options;
    
                    console.log(options);
                    amisScoped.updateProps({
                      data: {p1: progress * 100}
                    });
                  },
                  onStateChange: (state, data) => {
                    if (state === 'completed') {
 pushNotify({title: 'Upload', text: 'Upload successful'});
                      console.log(data);
                    } else if (state === 'failed') {
 pushNotify({status: 'error', title: 'Upload failed', text: data.message});
                    } else if (state === 'cancelled') {
 pushNotify({title: 'Upload', text: // Upload task cancelled'});
                    } else if (state === 'inited') {
 pushNotify({title: 'Upload', text: 'Upload task initialization completed'});
                    } else if (state === 'running') {
 pushNotify({title: 'Upload', text: 'Upload task starts running...'});
                    } else if (state === 'paused') {
 pushNotify({title: 'Upload', text: 'Upload task has been paused'});
                    }
                  }
                });
    
                const tasks = await SuperUpload.start();
 console.log('Slice list: ', tasks);
              };
            }
            
            function pause() {
              if (SuperUpload) {
                SuperUpload.pause();
              } else {
 pushNotify({status: 'error', title: 'Pause', text: 'Instance does not exist'});
              }
            }
    
            function resume() {
              if (SuperUpload) {
                SuperUpload.resume();
              } else {
 pushNotify({status: 'error', title: 'Resume', text: 'Instance does not exist'});
              }
            }
    
            async function cancel() {
              if (SuperUpload) {
                const result = await SuperUpload.cancel();
    
                if (result) {
                  SuperUpload = undefined;
                  p1 = 0;
    
                  amisScoped.updateProps({
                    data: {p1: 0}
                  });
                }
              } else {
 pushNotify({status: 'error', title: 'Cancel task', text: 'Instance does not exist'});
              }
            }
            
            const amis = amisRequire('amis/embed');
            const amisJSON = {
              type: 'page',
              body: [
                {
                  type: 'alert',
 title: 'CORS Configuration',
 body: 'If the API reports a CORS error, please enable the <a href="https://cloud.baidu.com/doc/BOS/s/Dk6kqw1g8", target="__blank">CORS configuration</a> for the corresponding bucket',
                  level: 'warning',
                  showIcon: true,
                  className: 'mb-3'
                },
                {
                  type: 'custom',
                  name: 'file',
                  onMount: (dom, value, onChange, props) => {
                    const input = document.createElement('input');
                    input.setAttribute('type', 'file');
                    input.setAttribute('id', 'file');
    
                    dom.appendChild(input);
                  }
                },
                {
                  type: 'progress',
                  value: '${p1}',
                  style: {
                    marginTop: '20px',
                    width: '500px'
                  }
                },
                {
                  type: 'flex',
                  justify: 'flex-start',
                  style: {
                    marginTop: '20px'
                  },
                  items: [
                    {
                      type: 'button',
                      level: 'primary',
 label: // Get instance,
                      style: {
                        marginRight: '10px'
                      },
                      onClick: getInstance
                    },
                    {
                      type: 'button',
                      level: 'primary',
 label: 'Upload',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: start
                    },
                    {
                      type: 'button',
                      level: 'primary',
 label: 'Pause',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: pause
                    },
                    {
                      type: 'button',
                      level: 'primary',
 label: 'Resume',
                      style: {
                        marginRight: '10px'
                      },
                      onClick: resume
                    },
                    {
                      type: 'button',
                      level: 'danger',
 label: 'Cancel',
                      onClick: cancel
                    }
                  ]
                }
              ]
            };
            const amisScoped = amis.embed('#root', amisJSON, {data: {p1}});
        })()
      </script>
  </body>
</html>
            

Set Http Header and custom meta data for object

The SDK essentially invokes the backend HTTP API, allowing the BOS service to enable users to customize HTTP headers. It also lets users add custom metadata to the object being uploaded. For example, the putObjectFromFile() function can handle this with the following code:

Example code

                JavaScript
                
            

                let options = {
 'Content-Type': 'application/json', // Add http header
 'Cache-Control': 'public, max-age=31536000', // Specify cache directives
 'Content-Disposition': 'attachment; filename="example.jpg"', // Indicate how the response content should be displayed
 'x-bce-meta-foo1': 'bar1', // Add custom meta information
 'x-bce-meta-foo2': 'bar2', // Add custom meta information
 'x-bce-meta-foo3': 'bar3', // Add custom meta information
}
client.putObjectFromFile(bucket, object, <path-to-file>, options)
  .then(done)
  .catch(fail);
            

Plain Text

1> **Note:** The key of custom Meta information needs to start with `x-bce-meta-`.

Obtain upload progress

The JavaScript SDK provides real-time upload progress information, which can be accessed by listening to the process event. This feature is supported by all upload-related APIs.

Example code: taking the putObjectFromBlob API as an example

                JavaScript
                
            

                // Upload in blob object form, only supported in browser environment
 client.putObjectFromBlob(bucket, object, <blob object>)
  .then(done)
  .catch(fail);
client.on('progress', function() {
    // do something
})
            

Synchronous callback

The JavaScript SDK supports the BOS server-side synchronous callback API. By adding x-bce-process in the request header or adding x-bce-process in the url query to specify the callback server address and related parameter configurations, the BOS server can actively call the callback API to notify the client after the upload is completed.

Currently, only normal upload (PutObject) and complete multipart upload (CompleteMultipartUpload) are supported

Method 1:

Use the callback parameter, and the SDK will help you process the parameters and add them to the request header

                Javascript
                
            

                try {
  const res = await client.putObjectFromString('bucketName', 'fileName', 'demo-string', {
      callback: {
        urls: ["https://www.test.com/callback"],
        vars: {name: 'baidu'},
        encrypt: 'config',
        key: 'callback1'
      }
  });
  /* callback result */
  console.log(res.body.callback.result);
} catch (e) {
  /* callback error code */
  console.error(res.body.callback.code);
  /* callback error message */
  console.error(res.body.callback.message);
}
            

Method 2:

Handle the parameters yourself, and add the "x-bce-process" parameter and its value to the request header

                Javascript
                
            

                try {
  const res = await client.putObjectFromString('bucketName', 'fileName', 'demo-string', {
      'x-bce-process': 'callback/callback,u_WyJodHRwczovL3d3dy50ZXN0LmNvbS9jYWxsYmFjayJd,m_sync,v_eyJuYW1lIjoiYmFpZHUifQ'
  });
  /* callback result */
  console.log(res.body.callback.result);
} catch (e) {
  /* callback error code */
  console.error(res.body.callback.code);
  /* callback error message */
  console.error(res.body.callback.message);
}
            

Copy Object

Get File URL