Upload File

Purpose

To upload a CSV file in ZIP format for bulk write API. The response contains the file_id. Use this ID while making the bulk write request.

For modules that have subforms, line items, multi-select lookup, and multi-user lookup, you can zip multiple CSV files together. For example, if your Leads module has a subform, then Leads is the parent and subform is the child. So, you must prepare two CSV files and zip them together to import data from both in a single bulk write job.

Endpoints

POST /upload

Request Details

Request URL

https://content.zohoapis.com/crm/v2/upload

Header

Authorization: Zoho-oauthtoken d92d4xxxxxxxxxxxxx15f52

feature: bulk-write - To indicate this is a bulk write job

X-CRM-ORG: zgid - The unique ID (zgid) of your organization obtained through the Organization API

Scope

scope=ZohoFiles.files.ALL

Input form-data

filefile, mandatory
Choose the zip file you want to upload.

Sample Request

Curl Java PHP Csharp Python Node JS Ruby JavaScript TypeScript

Copiedcurl "https://content.zohoapis.com/crm/v2/upload"
-X POST
-H "Authorization: Zoho-oauthtoken 1000.8cb99dxxxxxxxxxxxxx9be93.9b8xxxxxxxxxxxxxxxf"
-H "X-CRM-ORG: 56xxxx47"
-H "feature: bulk-write"
-F "file=@file.csv.zip"

3.0.08.0

CopiedString absoluteFilePath = "/Users/user_name/Documents/Leads.zip";
String orgID = "12345678";

//Get instance of BulkWriteOperations Class
BulkWriteOperations bulkWriteOperations = new BulkWriteOperations();

//Get instance of FileBodyWrapper class that will contain the request file
com.zoho.crm.api.bulkwrite.FileBodyWrapper fileBodyWrapper = new com.zoho.crm.api.bulkwrite.FileBodyWrapper();

//Get instance of StreamWrapper class that takes absolute path of the file to be attached as parameter
StreamWrapper streamWrapper = new StreamWrapper(absoluteFilePath);

//FileInputStream stream = new FileInputStream(absoluteFilePath);

//Get instance of StreamWrapper class that takes file name and stream of the file to be attached as parameter
//StreamWrapper streamWrapper = new StreamWrapper("Leads.zip", stream);

//Set file to the FileBodyWrapper instance
fileBodyWrapper.setFile(streamWrapper);

//Get instance of HeaderMap Class
HeaderMap headerInstance = new HeaderMap();

//To indicate that this a bulk write operation
headerInstance.add(UploadFileHeader.FEATURE, "bulk-write");

headerInstance.add(UploadFileHeader.X_CRM_ORG, orgID);

//Call uploadFile method that takes FileBodyWrapper instance and headerInstance as parameter
APIResponse < ActionResponse > response = bulkWriteOperations.uploadFile(fileBodyWrapper, headerInstance);

Copiedimport java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.ByteArrayBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
public class UploadFile 
{
	public static void main(String[] args) 
	{
		try
		{
			HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
			SSLContext sslContext = SSLContext.getDefault();
			SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
			CloseableHttpClient httpclient = httpClientBuilder.setSSLSocketFactory(sslConnectionSocketFactory).build();
			URIBuilder uriBuilder = new URIBuilder("https://content.zohoapis.com/crm/v2/upload");
			HttpUriRequest requestObj = new HttpPost(uriBuilder.build());
			HttpEntityEnclosingRequestBase requestBase = (HttpEntityEnclosingRequestBase) requestObj;
			requestObj.addHeader("feature", "bulk-write");
			requestObj.addHeader("X-CRM-ORG", "xxxx");
			requestObj.addHeader("Authorization", "Zoho-oauthtoken 1000.xxxxxxxxx.xxxxxxx");
			MultipartEntityBuilder multipartEntity = MultipartEntityBuilder.create();
			java.io.File file = new java.io.File("/Users/username/Documents/Leads.zip");
			@SuppressWarnings("resource")
			InputStream stream = new FileInputStream(file);
			byte[] buffer = new byte[8192];
			ByteArrayOutputStream output = new ByteArrayOutputStream();
			int bytesRead;
			while ((bytesRead = stream.read(buffer)) != -1)
			{
			    output.write(buffer, 0, bytesRead);
			}
			multipartEntity.addPart("file", new ByteArrayBody(output.toByteArray(), file.getName()));
			requestBase.setEntity(multipartEntity.build());
			HttpResponse response = httpclient.execute(requestObj);
			HttpEntity responseEntity = response.getEntity();
			Object responseObject = EntityUtils.toString(responseEntity);
			String responseString = responseObject.toString();
			System.out.println(responseString);
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
}

3.0.07.x

Copied//Get instance of BulkWriteOperations Class
$bulkWriteOperations = new BulkWriteOperations();
//Get instance of FileBodyWrapper class that will contain the request file
$fileBodyWrapper = new FileBodyWrapper();
//Get instance of StreamWrapper class that takes absolute path of the file to be attached as parameter
$streamWrapper = new StreamWrapper(null, null, $absoluteFilePath);
// $file = fopen($absoluteFilePath, "rb");
// $stream = fread($file, filesize($absoluteFilePath));
// fclose($file);
//Get instance of StreamWrapper class that takes file name and stream of the file to be attached as parameter
// $streamWrapper = new StreamWrapper(basename($absoluteFilePath), $stream);
//Set file to the FileBodyWrapper instance
$fileBodyWrapper->setFile($streamWrapper);
//Get instance of HeaderMap Class
$headerInstance = new HeaderMap();
//To indicate that this a bulk write operation
$headerInstance->add(UploadFileHeader::feature(), "bulk-write");
$headerInstance->add(UploadFileHeader::XCRMORG(), $orgID);
//Call uploadFile method that takes FileBodyWrapper instance and headerInstance as parameter
$response = $bulkWriteOperations->uploadFile($fileBodyWrapper, $headerInstance);

Copied<?php

class UploadFile
{
	public function execute(){
        $curl_pointer = curl_init();
        
        $curl_options = array();
        $curl_options[CURLOPT_URL] = "https://content.zohoapis.com/crm/v2/upload";
        $curl_options[CURLOPT_RETURNTRANSFER] = true; 
        $curl_options[CURLOPT_HEADER] = 1;
        $curl_options[CURLOPT_CUSTOMREQUEST] = "POST";
        $fileName = "asdad.zip";
        $filePath = "/Users/test/PHP/PHPNativeSampleCode/asdad.zip";
        $file = fopen($filePath, "rb");
        $fileData = fread($file, filesize($filePath));
        $date = new \DateTime();
        
        
        $current_time_long= $date->getTimestamp();
        
        $lineEnd = "\r\n";
        
        $hypen = "--";
        
        $contentDisp = "Content-Disposition: form-data; name=\""."file"."\";filename=\"".$fileName."\"".$lineEnd.$lineEnd;
        
        
        $data = utf8_encode($lineEnd);
        
        $boundaryStart = utf8_encode($hypen.(string)$current_time_long.$lineEnd) ;
        
        $data = $data.$boundaryStart;
        
        $data = $data.utf8_encode($contentDisp);
        
        $data = $data.$fileData.utf8_encode($lineEnd);
        
        $boundaryend = $hypen.(string)$current_time_long.$hypen.$lineEnd.$lineEnd;
        
        $data = $data.utf8_encode($boundaryend);
        
        $curl_options[CURLOPT_POSTFIELDS]= $data;
        $headersArray = array();
        
        $headersArray = ['ENCTYPE: multipart/form-data','Content-Type:multipart/form-data;boundary='.(string)$current_time_long];
        $headersArray[] = "content-type".":"."multipart/form-data";
        $headersArray[] = "feature".":"."bulk-write";
        $headersArray[] = "X-CRM-ORG".":"."680100987";
        $headersArray[] = "Authorization". ":" . "Zoho-oauthtoken " ."1000.8cb99dxxxxxxxxxxxxx9be93.9b8xxxxxxxxxxxxxxxf";
        var_dump($data);

        $curl_options[CURLOPT_HTTPHEADER]=$headersArray;
        
        curl_setopt_array($curl_pointer, $curl_options);

        $result = curl_exec($curl_pointer);
        $responseInfo = curl_getinfo($curl_pointer);
        curl_close($curl_pointer);
        list ($headers, $content) = explode("\r\n\r\n", $result, 2);
        if(strpos($headers," 100 Continue")!==false){
            list( $headers, $content) = explode( "\r\n\r\n", $content , 2);
        }
        $headerArray = (explode("\r\n", $headers, 50));
        $headerMap = array();
        foreach ($headerArray as $key) {
            if (strpos($key, ":") != false) {
                $firstHalf = substr($key, 0, strpos($key, ":"));
                $secondHalf = substr($key, strpos($key, ":") + 1);
                $headerMap[$firstHalf] = trim($secondHalf);
            }
        }
        $jsonResponse = json_decode($content, true);
        if ($jsonResponse == null && $responseInfo['http_code'] != 204) {
            list ($headers, $content) = explode("\r\n\r\n", $content, 2);
            $jsonResponse = json_decode($content, true);
        }
        var_dump($headerMap);
        var_dump($jsonResponse);
        var_dump($responseInfo['http_code']);
       
    }
    
}
(new UploadFile())->execute();

3.0.08.x

Copied//Get instance of BulkWriteOperations Class
BulkWriteOperations bulkWriteOperations = new BulkWriteOperations();
//Get instance of FileBodyWrapper class that will contain the request file
FileBodyWrapper fileBodyWrapper = new FileBodyWrapper();
//Get instance of StreamWrapper class that takes absolute path of the file to be attached as parameter
StreamWrapper streamWrapper = new StreamWrapper(absoluteFilePath);
//FileInfo fileInfo = new FileInfo(absoluteFilePath);
//Get instance of StreamWrapper class that takes file name and stream of the file to be attached as parameter
//StreamWrapper streamWrapper = new StreamWrapper(fileInfo.Name, fileInfo.OpenRead());
//Set file to the FileBodyWrapper instance
fileBodyWrapper.File = streamWrapper;
//Get instance of HeaderMap Class
HeaderMap headerInstance = new HeaderMap();
//To indicate that this a bulk write operation
headerInstance.Add(UploadFileHeader.FEATURE, "bulk-write");
headerInstance.Add(UploadFileHeader.X_CRM_ORG, orgID);
//Call uploadFile method that takes FileBodyWrapper instance and headerInstance as parameter
APIResponse<ActionResponse> response = bulkWriteOperations.UploadFile(fileBodyWrapper, headerInstance);

Copiedusing System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
namespace Com.Zoho.Crm.API.Sample.RestAPI.BulkWrite
{
    public class UploadFile
    {
        public static void UploadBulkWriteFile()
        {
            string boundary = "----FILEBOUNDARY----";
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://content.zohoapis.com/crm/v2/upload");
            request.ContentType = "multipart/form-data; boundary=" + boundary;
            request.Method = "POST";
            request.Headers["Authorization"] = "Zoho-oauthtoken 1000.abfeXXXXXXXXXXX2asw.XXXXXXXXXXXXXXXXXXsdc2";
            request.Headers["feature"] =  "bulk-write";
            request.Headers["X-CRM-ORG"] = "673573045";
            request.KeepAlive = true;
            FileInfo fileInfo = new FileInfo("/Users/abc-123/Documents/JAVASDK/csvfile/upload/insert/Leads.zip");
            string name = fileInfo.Name;
            Stream stream = fileInfo.OpenRead();
            Stream fileDataStream = new MemoryStream();
            var boundarybytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "\r\n");
            var endBoundaryBytes = Encoding.UTF8.GetBytes("\r\n--" + boundary + "--");
            string headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\n" + "Content-Type: application/octet-stream\r\n\r\n";
            fileDataStream.Write(boundarybytes, 0, boundarybytes.Length);
            var header = string.Format(headerTemplate, "file", name);
            var headerbytes = System.Text.Encoding.UTF8.GetBytes(header);
            fileDataStream.Write(headerbytes, 0, headerbytes.Length);
            var buffer = new byte[1024];
            var bytesRead = 0;
            while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
            {
                fileDataStream.Write(buffer, 0, bytesRead);
            }
            fileDataStream.Write(endBoundaryBytes, 0, endBoundaryBytes.Length);
            request.ContentLength = fileDataStream.Length;
            using (Stream requestStream = request.GetRequestStream())
            {
                fileDataStream.Position = 0;
                byte[] tempBuffer = new byte[fileDataStream.Length];
                fileDataStream.Read(tempBuffer, 0, tempBuffer.Length);
                fileDataStream.Close();
                requestStream.Write(tempBuffer, 0, tempBuffer.Length);
            }
            HttpWebResponse response;
            try
            {
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException e)
            {
                if (e.Response == null) { throw; }
                response = (HttpWebResponse)e.Response;
            }
            HttpWebResponse responseEntity = response;
            string responsestring = new StreamReader(responseEntity.GetResponseStream()).ReadToEnd();
            responseEntity.Close();
            Console.WriteLine(responsestring);
        }
    }
}

3.0.03.x.x

Copied# Get instance of BulkWriteOperations Class
bulk_write_operations = BulkWriteOperations()
# Get instance of FileBodyWrapper class that will contain the request file
file_body_wrapper = FileBodyWrapper()
"""
StreamWrapper can be initialized in any of the following ways
* param 1 -> fileName 
* param 2 -> Read Stream.
"""
# stream_wrapper = StreamWrapper(stream=open(absolute_file_path, 'rb'))
"""
* param 1 -> fileName
* param 2 -> Read Stream
* param 3 -> Absolute File Path of the file to be attached
"""
stream_wrapper = StreamWrapper(file_path=absolute_file_path)
# Set file to the FileBodyWrapper instance
file_body_wrapper.set_file(stream_wrapper)
# Get instance of HeaderMap Class
header_instance = HeaderMap()
# Possible parameters for upload_file operation
header_instance.add(UploadFileHeader.feature, "bulk-write")
header_instance.add(UploadFileHeader.x_crm_org, org_id)
# Call upload_file method that takes FileBodyWrapper instance and header_instance as parameter
response = bulk_write_operations.upload_file(file_body_wrapper, header_instance)

Copieddef upload_file():
    import requests

    url = 'https://content.zohoapis.com/crm/v2/upload'

    headers = {
        'Authorization': 'Zoho-oauthtoken 1000.04be928e4a96XXXXXXXXXXXXX68.0b9eXXXXXXXXXXXX60396e268',
        'feature': 'bulk-write',
        'X-CRM-ORG': '673899828'
    }

    request_body = {
        'file': open('/Users/abc-123/Documents/SDK-workspace/latest-git-csez/python/latest/zohocrm-python-sdk/Leads.zip', 'rb')
    }

    response = requests.post(url=url, headers=headers, data=request_body)

    if response is not None:
        print("HTTP Status Code : " + str(response.status_code))

        print(response.json())

upload_file()

1.0.010.x

Copied//Get instance of BulkWriteOperations Class
let bulkWriteOperations = new BulkWriteOperations();
//Get instance of FileBodyWrapper class that will contain the request file
let fileBodyWrapper = new FileBodyWrapper();
/** StreamWrapper can be initialized in any of the following ways */ 
/**
 * param 1 -> fileName 
 * param 2 -> Read Stream.
 */
let streamWrapper = new StreamWrapper(null, fs.createReadStream(absoluteFilePath));
/**
 * param 1 -> fileName
 * param 2 -> Read Stream
 * param 3 -> Absolute File Path of the file to be attached
 */
// let streamWrapper = new StreamWrapper(null, null, absoluteFilePath);
//Set file to the FileBodyWrapper instance
fileBodyWrapper.setFile(streamWrapper);
//Get instance of HeaderMap Class
let headerInstance = new HeaderMap();
//To indicate that this a bulk write operation
await headerInstance.add(UploadFileHeader.FEATURE, "bulk-write");
await headerInstance.add(UploadFileHeader.X_CRM_ORG, orgID);
//Call uploadFile method that takes FileBodyWrapper instance and headerInstance as parameter
let response = await bulkWriteOperations.uploadFile(fileBodyWrapper, headerInstance);

Copiedasync function uploadFile() {
    const got = require('got');
    const FormData = require("form-data");
    const fs = require("fs");

    let url = 'https://content.zohoapis.com/crm/v2/upload'

    let headers = {
        'Authorization': 'Zoho-oauthtoken 1000.8cb99dxxxxxxxxxxxxx9be93.9b8xxxxxxxxxxxxxxxf',
        'feature': 'bulk-write',
        'X-CRM-ORG': '673899828'
    }

    let requestBody = new FormData()
    requestBody.append('file', fs.createReadStream('/Users/abc-123/Documents/Leads.zip'))

    let requestDetails = {
        method : "POST",
        headers : headers,
        body : requestBody,
        encoding: "utf8",
        throwHttpErrors : false
    }

    let response = await got(url, requestDetails)
    
    if(response != null) {
        console.log(response.statusCode);
        console.log(response.body);
    } 
}
uploadFile()

2.02.x.x

Copied# Get instance of BulkWriteOperations Class
bwo = BulkWrite::BulkWriteOperations.new
# Get instance of FileBodyWrapper class that will contain the request file
file_body_wrapper = BulkWrite::FileBodyWrapper.new
# """
# StreamWrapper can be initialized in any of the following ways

# * param 1 -> fileName
# * param 2 -> Read Stream.
# * param 3 -> Absolute File Path of the file to be attached
# """
# stream_wrapper = StreamWrapper.new(name,stream,absolutefilepath)
sw = Util::StreamWrapper.new(nil, nil, '/Users/user_name/RUBYWS/zohocrm-rubysdk-sample-application/3524033000005787003.zip')
# Set file to the FileBodyWrapper instance
file_body_wrapper.file = sw
# Get instance of HeaderMap Class
header_instance = HeaderMap.new
# Possible headers for upload_file operation
header_instance.add(BulkWrite::BulkWriteOperations::UploadFileHeader.feature, 'bulk-write')
header_instance.add(BulkWrite::BulkWriteOperations::UploadFileHeader.X_crm_org, org_id)
# Call upload_file method that takes FileBodyWrapper instance and header_instance as parameter
response = bwo.upload_file(file_body_wrapper, header_instance)

Copiedclass UploadFile 

    def execute
      
        url = "https://content.zohoapis.com/crm/v2/upload"
        url = URI(url)
        req = Net::HTTP::Post.new(url.request_uri)
        http = Net::HTTP.new(url.host, url.port)
        http.use_ssl = true
        headers={}
        headers["Authorization"]="Zoho-oauthtoken 1000.50XXXXXXXXX&77e3a.44XXXXXXXXX8353"
        headers["content-type"]="multipart/form-data"
        headers["feature"]="bulk-write"
        headers["X-CRM-ORG"]="680100987"
        headers&.each { |key, value| req.add_field(key, value) }
        file_path = "/Users/test/Desktop/pic.png"
        file = File.open(file_path)
        data=[["file",file.read, { filename: "pic.png" }]]
        req.set_form(data,'multipart/form-data')
        response=http.request(req)
        status_code = response.code.to_i
        headers = response.each_header.to_h
        print status_code
        print headers
        unless response.body.nil?
            print  response.body
        end
    end
end
UploadFile.new.execute

1.0.0ES6

Copied//Get instance of BulkWriteOperations Class
let bulkWriteOperations = new ZCRM.BulkWrite.Operations();
//Get instance of FileBodyWrapper class that will contain the request file
let fileBodyWrapper = new ZCRM.BulkWrite.Model.FileBodyWrapper();
/** StreamWrapper can be initialized in any of the following ways */
var filesToLoad  = document.getElementById("bulk_write").files;
var file = filesToLoad[0];
/**
 * param 1 -> fileName
 * param 2 -> Read Stream
 */
let streamWrapper = new StreamWrapper.Model.StreamWrapper(null, file);
//Set file to the FileBodyWrapper instance
fileBodyWrapper.setFile(streamWrapper);
//Get instance of HeaderMap Class
let headerInstance = new HeaderMap();
//To indicate that this a bulk write operation
await headerInstance.add(ZCRM.BulkWrite.Model.UploadFileHeader.FEATURE, "bulk-write");
await headerInstance.add(ZCRM.BulkWrite.Model.UploadFileHeader.X_CRM_ORG, orgID);
//Call uploadFile method that takes FileBodyWrapper instance and headerInstance as parameter
let response = await bulkWriteOperations.uploadFile(fileBodyWrapper, headerInstance);

Copiedvar listener = 0;
class UploadFile {

	async uploadFile() {

        var url = "https://content.zohoapis.com/crm/v2/upload"
        var parameters = new Map()
        var headers = new Map()
        var token = {
            clientId:"1000.NPY9M1V0XXXXXXXXXXXXXXXXXXXF7H",
            redirectUrl:"http://127.0.0.1:5500/redirect.html",
            scope:"ZohoCRM.users.ALL,ZohoCRM.bulk.read,ZohoCRM.modules.ALL,ZohoCRM.settings.ALL,Aaaserver.profile.Read,ZohoCRM.org.ALL,profile.userphoto.READ,ZohoFiles.files.ALL,ZohoCRM.bulk.ALL,ZohoCRM.settings.variable_groups.ALL"
        }
        var accesstoken = await new UploadFile().getToken(token)
        headers.set("feature", "bulk-write")
        headers.set("X-CRM-ORG", "123456778")
        headers.set("Authorization", "Zoho-oauthtoken " + accesstoken)

        var filesToLoad  = document.getElementById("bulk_write").files;
        var file = filesToLoad[0];

        var requestMethod = "POST"
        var formDataRequestBody = new FormData();
        formDataRequestBody.append("file", new Blob([file]),file.name);
        var reqBody = formDataRequestBody
        var params = "";
        parameters.forEach(function(value, key) {
            if (parameters.has(key)) {
                if (params) {
                    params = params + key + '=' + value + '&';
                }
                else {
                    params = key + '=' + value + '&';
                }
            }
        });
        var apiHeaders = {};
        if(headers) {
            headers.forEach(function(value, key) {
                apiHeaders[key] = value;
            });
        }
        if (params.length > 0){
            url = url + '?' + params.substring(0, params.length - 1);
        }
        var requestObj = {
            uri : url,
            method : requestMethod,
            headers : apiHeaders,
            body : reqBody,
            encoding: "utf8",
            allowGetBody : true,
			throwHttpErrors : false
        };
        var result = await new UploadFile().makeAPICall(requestObj);
        console.log(result.status)
        console.log(result.response)
    }

    async getToken(token) {

        if(listener == 0) {

            window.addEventListener("storage", function(reponse) {
                if(reponse.key === "access_token" && (reponse.oldValue != reponse.newValue || reponse.oldValue == null)){
                    location.reload();
                }
                if(reponse.key === "access_token"){

                    sessionStorage.removeItem("__auth_process");
                }
            }, false);
            listener = 1;
            if(sessionStorage.getItem("__auth_process")) {
                sessionStorage.removeItem("__auth_process");
            }
        }
        ["granted_for_session", "access_token","expires_in","expires_in_sec","location","api_domain","state","__token_init","__auth_process"].forEach(function (k) {
            var isKeyExists = localStorage.hasOwnProperty(k);
            if(isKeyExists) {
                sessionStorage.setItem(k, localStorage[k]);
            }
            localStorage.removeItem(k);
        });
        var valueInStore = sessionStorage.getItem("access_token");
        var tokenInit = sessionStorage.getItem("__token_init");
        if(tokenInit != null && valueInStore != null && Date.now() >= parseInt(tokenInit) + 59 * 60 * 1000){ // check after 59th minute
            valueInStore = null;
            sessionStorage.removeItem("access_token");
        }

        var auth_process = sessionStorage.getItem("__auth_process");
        if ((valueInStore == null && auth_process == null) || (valueInStore == 'undefined' && (auth_process == null || auth_process == "true"))) {
            var accountsUrl = "https://accounts.zoho.com/oauth/v2/auth"
            var clientId;
            var scope;
            var redirectUrl;
            if(token != null) {
                clientId = token.clientId;
                scope = token.scope;
                redirectUrl = token.redirectUrl;
            }

            var fullGrant = sessionStorage.getItem("full_grant");
            var grantedForSession = sessionStorage.getItem("granted_for_session");
            if(sessionStorage.getItem("__token_init") != null && ((fullGrant != null && "true" == full_grant) || (grantedForSession != null && "true" == grantedForSession))) {
                accountsUrl += '/refresh';
            }
            if (clientId && scope) {
                sessionStorage.setItem("__token_init", Date.now());
                sessionStorage.removeItem("access_token");
                sessionStorage.setItem("__auth_process", "true");
                window.open(accountsUrl + "?" + "scope" + "=" + scope + "&"+ "client_id" +"=" + clientId + "&response_type=token&state=zohocrmclient&redirect_uri=" + redirectUrl);
                ["granted_for_session", "access_token","expires_in","expires_in_sec","location","api_domain","state","__token_init","__auth_process"].forEach(function (k) {
                    var isKeyExists = localStorage.hasOwnProperty(k);
                    if(isKeyExists){
                        sessionStorage.setItem(k, localStorage[k]);
                    }
                    localStorage.removeItem(k);
                });
                valueInStore = sessionStorage.getItem("access_token");
            }
        }
        if(token != null && valueInStore != 'undefined'){
            token.accessToken = valueInStore;
        }
        return token.accessToken;
    }

    async makeAPICall(requestDetails) {
        return new Promise(function (resolve, reject) {
            var body, xhr, i;
            body = requestDetails.body || null;
            xhr = new XMLHttpRequest();
            xhr.withCredentials = true;
            xhr.open(requestDetails.method, requestDetails.uri, true);
            for (i in requestDetails.headers) {
                xhr.setRequestHeader(i, requestDetails.headers[i]);
            }
            xhr.send(body);
            xhr.onreadystatechange = function() {
                if(xhr.readyState == 4) {
                    resolve(xhr);
                }
            }
        })
    }
}

1.0.14.x.x

Copied//Get instance of BulkWriteOperations Class
let bulkWriteOperations: BulkWriteOperations = new BulkWriteOperations();

//Get instance of FileBodyWrapper class that will contain the request file
let fileBodyWrapper: FileBodyWrapper = new FileBodyWrapper();

/** StreamWrapper can be initialized in any of the following ways */

/**
 * param 1 -> fileName
 * param 2 -> Read Stream.
 */
let streamWrapper: StreamWrapper = new StreamWrapper(undefined, fs.createReadStream(absoluteFilePath));

/**
 * param 1 -> fileName
 * param 2 -> Read Stream
 * param 3 -> Absolute File Path of the file to be attached
 */
// let streamWrapper = new StreamWrapper(null, null, absoluteFilePath);

//Set file to the FileBodyWrapper instance
fileBodyWrapper.setFile(streamWrapper);

//Get instance of HeaderMap Class
let headerInstance: HeaderMap = new HeaderMap();

//To indicate that this a bulk write operation
await headerInstance.add(UploadFileHeader.FEATURE, "bulk-write");

await headerInstance.add(UploadFileHeader.X_CRM_ORG, orgID);

//Call uploadFile method that takes FileBodyWrapper instance and headerInstance as parameter
let response: APIResponse < ActionResponse > = await bulkWriteOperations.uploadFile(fileBodyWrapper, headerInstance);

Copiedimport got from 'got';
var FormData = require('form-data');
import { createReadStream } from "fs";
class UploadFile {
	public async main()  {
		var apiHeaders: {[key: string]: string} = {};
		var apiParameters: {[key: string]: string} = {};
		var modifiedRequestBody: any= new FormData();
		const readStream =  createReadStream('/Users/username/Documents/File.zip');
		modifiedRequestBody.append('file',readStream);
		apiHeaders["Authorization"] = "Zoho-oauthtoken 1000.xxxxxxx.xxxxxx"
		apiHeaders["X-CRM-ORG"]= "xxxx"
		apiHeaders["feature"]= "bulk-write"
		var requestDetails: {[key: string]: any} = {
			method : "POST",
			headers : apiHeaders,
			searchParams : apiParameters,
			body : modifiedRequestBody,
 			encoding: "utf8",
			allowGetBody : true,
			throwHttpErrors : false
		};
		var response = await got("https://content.zohoapis.com/crm/v2/upload", requestDetails);
		console.log(response.statusCode)
		console.log(JSON.parse(response.body));
	}

}
var v = new UploadFile()

v.main()

Possible Errors

INVALID_FILE_FORMATHTTP 400
The file you uploaded is not in the zip format.
Resolution: Upload the file only in the zip format.
FILE_TOO_LARGEHTTP 400
The file size is too large to process.
Resolution: The maximum file size is 25MB.
INVALID_URL_PATTERNHTTP 404
Please check if the URL trying to access is a correct one
Resolution: The request URL specified is incorrect. Specify a valid request URL. Refer to request URL section above.
OAUTH_SCOPE_MISMATCHHTTP 401
Unauthorized
Resolution: Client does not have ZohoFiles.files.ALL. Create a new client with valid scope. Refer to scope section above.
NO_PERMISSIONHTTP 403
Permission denied to create
Resolution: The user does not have permission to upload files. Contact your system administrator.
INTERNAL_ERRORHTTP 500
Internal Server Error
Resolution: Unexpected and unhandled exception in Server. Contact support team.
INVALID_REQUEST_METHODHTTP 400
The http request method type is not a valid one
Resolution: You have specified an invalid HTTP method to access the API URL. Specify a valid request method. Refer to endpoints section above.
AUTHORIZATION_FAILEDHTTP 400
User does not have sufficient privilege to create.
Resolution: The user does not have the permission to upload file. Contact your system administrator.

Note

Refer to the Limitations to know the CSV file limits.

Sample Response

Copied{
    "status": "success",
    "code": "FILE_UPLOAD_SUCCESS",
    "message": "file uploaded.",
    "details": {
        "file_id": "111111000001492610",
        "created_time": "2018-12-31T12:00:00-12:00"
    }
    }