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.

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.
For modules such as Leads and Contacts, you can ZIP one CSV file in it, with a maximum of 25,000 records. If there are more records, make a separate API call by with a ZIP file containing the next 25,000 records in the module.
Please note that the Subform and multi-module lookup (MxN linking module) fields are treated as separate modules in Zoho CRM. This is a parent-child modulecase, for example, the Contacts module is the parent module, and the subform within it is the child module. So, prepare separate CSV files for parent and child modules, then ZIP them together into a ZIP file and upload.
For more details on preparing the input file for parent-child record imports, refer to Kaizen #131 - Bulk Write for parent-child records using Scala SDK.

Note

To import parent-child module data in a single Bulk Write request:
- Add multiple CSV files in one ZIP file.
- Field mapping is mandatory.
To import subform or linking module records, specify their respective API names in the input request. Refer to the Create Bulk Write Job API for more details.

Sample Request

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()

Show full

Show less

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 page to learn more about 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"
    }
    }

CRM

Voice

Sign

Forms

Bigin

SalesIQ

Bookings

RouteIQ

Thrive

CRM Plus

Zakya

Campaigns

Voice

Sign

Forms

Social

Survey

SalesIQ

Sites

Backstage

PageSense

Marketing Automation

LandingPage

Webinar

LeadChain

Domains

CommunitySpaces

Thrive

Publish

Marketing Plus

Commerce

Zakya

Desk

Assist

Voice

SalesIQ

Bookings

FSM

Lens

Solo

Service Plus

Books

Expense

Sign

Inventory

Invoice

Billing

Payroll

Commerce

Checkout

Practice

Solo

Payments

Finance Plus

Mail

Voice

Sign

WorkDrive

Bookings

Cliq

Notebook

Meeting

Connect

Learn

Office Integrator

Writer

TeamInbox

ZeptoMail

Show

Tables

Sheet

Office Suite

Calendar

ToDo

PDF Editor

Workplace

Vani

Expense

Recruit

People