Upload an Attachment

Purpose

To attach a file to a record. You must include the attachment in the request with content type as multipart/form data.

Request Details

Request URL

https://www.zohoapis.com/crm/v2/{module_api_name}/{record_id}/Attachments

Supported modules

Leads, Accounts, Contacts, Deals, Campaigns, Tasks, Cases, Events, Solutions, Products, Vendors, Price Books, Quotes, Sales Orders, Purchase Orders, Invoices, Custom, and Notes

Header

Authorization: Zoho-oauthtoken d92d4xxxxxxxxxxxxx15f52

Scope

scope=ZohoCRM.modules.ALL
(or)
scope=ZohoCRM.modules.{module_name}.{operation_type}
(and)
scope=ZohoCRM.modules.attachments.{operation_type}

Possible module names

leads, accounts, contacts, deals, campaigns, tasks, cases, events, solutions, products, vendors, pricebooks, quotes, salesorders, purchaseorders, invoices, custom, notes

Possible operation types

ALL - Full access to attachments
WRITE - Edit attachment data
CREATE - Create attachment data

Parameters

  • filefile, mandatory

    Choose the attachment you want to upload.
    Maximum allowed file size: 100 MB
    Allowed file types: All the file types except .exe

Sample Request

Copiedcurl "https://www.zohoapis.com/crm/v2/Leads/1000000231009/Attachments"
-X POST
-H "Authorization: Zoho-oauthtoken 1000.8cb99dxxxxxxxxxxxxx9be93.9b8xxxxxxxxxxxxxxxf"
-F "file=@attachment1.txt" (to upload file) 
(or)
-F "attachmentUrl=https://www.zohocorp.com" (to upload link)
3.0.08.0
CopiedString moduleAPIName = "Leads";
Long recordId = 3477061000005177002L;
String absoluteFilePath = "/Users/use_name/Desktop/image.png";

//Get instance of AttachmentsOperations Class that takes moduleAPIName and recordId as parameter
AttachmentsOperations attachmentsOperations = new AttachmentsOperations(moduleAPIName, recordId);

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

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

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

//Call uploadAttachment method that takes FileBodyWrapper instance as parameter
APIResponse < ActionHandler > response = attachmentsOperations.uploadAttachment(fileBodyWrapper);
Copiedpackage com.zoho.crm.api.sample.restapi.filesandattachments;
import 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 UploadanAttachment 
{
	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://www.zohoapis.com/crm/v2/Leads/34770617711001/Attachments");
			HttpUriRequest requestObj = new HttpPost(uriBuilder.build());
			HttpEntityEnclosingRequestBase requestBase = (HttpEntityEnclosingRequestBase) requestObj;
			requestObj.addHeader("Authorization", "Zoho-oauthtoken 1000.xxxxxxx.xxxxxxx");
			MultipartEntityBuilder multipartEntity = MultipartEntityBuilder.create();
			java.io.File file = new java.io.File("/Users/username/Desktop/zoho.jpeg");
			@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 AttachmentsOperations Class that takes recordId and moduleAPIName as parameter
$attachmentOperations = new AttachmentsOperations($moduleAPIName, $recordId);
//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);
//Set file to the FileBodyWrapper instance
$fileBodyWrapper->setFile($streamWrapper);
//Call uploadAttachment method that takes FileBodyWrapper instance as parameter
$response = $attachmentOperations->uploadAttachment($fileBodyWrapper);
Copied<?php

class UploadAttachment
{
	public function execute(){
        $curl_pointer = curl_init();
        
        $curl_options = array();
        $curl_options[CURLOPT_URL] = "https://www.zohoapis.com/crm/v2/Leads/35240335495065/Attachments";
        $curl_options[CURLOPT_RETURNTRANSFER] = true; 
        $curl_options[CURLOPT_HEADER] = 1;
        $curl_options[CURLOPT_CUSTOMREQUEST] = "POST";
        $fileName = "response.json";
        $filePath = "/Users/test/PHP/PHPNativeSampleCode/response.json";
        $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[] = "Authorization". ":" . "Zoho-oauthtoken " ."1000.8cb99dxxxxxxxxxxxxx9be93.9b8xxxxxxxxxxxxxxxf";

        $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 UploadAttachment())->execute();
3.0.08.x
Copied//Get instance of AttachmentsOperations Class that takes moduleAPIName and recordId as parameter
AttachmentsOperations attachmentsOperations = new AttachmentsOperations(moduleAPIName, recordId);
//Get instance of FileBodyWrapper class that will contain the request file
API.Attachments.FileBodyWrapper fileBodyWrapper = new API.Attachments.FileBodyWrapper();
//Get instance of StreamWrapper class that takes absolute path of the file to be attached as parameter
StreamWrapper streamWrapper = new StreamWrapper (absoluteFilePath);
//Set file to the FileBodyWrapper instance
fileBodyWrapper.File = streamWrapper;
//Call UploadAttachment method that takes FileBodyWrapper instance as parameter
APIResponse<API.Attachments.ActionHandler> response = attachmentsOperations.UploadAttachment(fileBodyWrapper);
Copiedusing System;
using System.IO;
using System.Net;
using System.Text;
namespace Com.Zoho.Crm.API.Sample.RestAPI.FilesandAttachments
{
    public class UploadanAttachment
    {
        public static void UploadAttachment()
        {
            string boundary = "----FILEBOUNDARY----";
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://www.zohoapis.com/crm/v2/Leads/347706107711001/Attachments");
            request.ContentType = "multipart/form-data; boundary=" + boundary;
            request.Method = "POST";
            request.Headers["Authorization"] = "Zoho-oauthtoken 1000.abfeXXXXXXXXXXX2asw.XXXXXXXXXXXXXXXXXXsdc2";
            request.KeepAlive = true;
            FileInfo fileInfo = new FileInfo("/Users/abc-123/Desktop/zoho.jpeg");
            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 AttachmentsOperations Class that takes module_api_name and record_id as parameters
attachments_operations = AttachmentsOperations(module_api_name, record_id)
# 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)
# Call upload_attachment method that takes FileBodyWrapper instance as parameter
response = attachments_operations.upload_attachment(file_body_wrapper)
Copieddef upload_an_attachment():
    import requests

    url = 'https://www.zohoapis.com/crm/v2/Leads/3409643000003088001/Attachments'

    headers = {
        'Authorization': 'Zoho-oauthtoken 1000.04be928e4a96XXXXXXXXXXXXX68.0b9eXXXXXXXXXXXX60396e268'
    }

    request_body = {
        'file': open(
            '/Users/abc-123/Documents/img_2.png',
            'rb')
    }

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

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

        print(response.json())

upload_an_attachment()
1.0.010.x
Copied//Get instance of AttachmentsOperations Class that takes recordId and moduleAPIName as parameter
let attachmentsOperations = new AttachmentsOperations(moduleAPIName, recordId);
//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);
//Call uploadAttachment method that takes FileBodyWrapper instance as parameter
let response = await attachmentsOperations.uploadAttachment(fileBodyWrapper);
Copiedasync function uploadAnAttachment() {
    const got = require("got");
    const FormData = require("form-data");
    const fs = require("fs");

    let url = 'https://www.zohoapis.com/crm/v2/Leads/3409643000003088001/Attachments'
    
    let headers = {
        Authorization : "Zoho-oauthtoken 1000.8cb99dxxxxxxxxxxxxx9be93.9b8xxxxxxxxxxxxxxxf"
    }

    let requestBody = new FormData()
    requestBody.append('file', fs.createReadStream('/Users/abc-123/Desktop/img.png'))

    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);
    }
}

uploadAnAttachment()
2.02.x.x
Copied# Get instance of AttachmentsOperations Class that takes record_id and module_api_name as parameters
ao = Attachments::AttachmentsOperations.new(module_api_name,record_id)
# Get instance of FileBodyWrapper class that will contain the request file
fbw = Attachments::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, absolute_file_path)
# Set file to the FileBodyWrapper instance
fbw.file = sw
# Call upload_attachment method that takes FileBodyWrapper instance as parameter
response = ao.upload_attachment(fbw)
Copiedclass UploadAttachment 

    def execute
      
        url = "https://www.zohoapis.com/crm/v2/Leads/3524033000005495065/Attachments"
        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&.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
UploadAttachment.new.execute
1.0.0ES6
Copied//Get instance of AttachmentsOperations Class that takes recordId and moduleAPIName as parameter
let attachmentsOperations = new ZCRM.Attachment.Operations(moduleAPIName, recordId);
//Get instance of FileBodyWrapper class that will contain the request file
let fileBodyWrapper = new ZCRM.Attachment.Model.FileBodyWrapper();
/** StreamWrapper can be initialized in any of the following ways */
var filesToLoad  = document.getElementById("attachment").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);
//Call uploadAttachment method that takes FileBodyWrapper instance as parameter
let response = await attachmentsOperations.uploadAttachment(fileBodyWrapper);
Copiedvar listener = 0;
class UploadanAttachment {

	async uploadAttachment()	{
		var url = "https://www.zohoapis.com/crm/v2/Leads/34770617711001/Attachments"
        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 UploadanAttachment().getToken(token)
        headers.set("Authorization", "Zoho-oauthtoken " + accesstoken)
        var filesToLoad  = document.getElementById("attachment").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 UploadanAttachment().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);
                }
            }
        })
    }
}

Possible Errors

  • INVALID_MODULEHTTP 400

    The module name given seems to be invalid
    Resolution: You have specified an invalid module name or there is no tab permission, or the module could have been removed from the available modules. Specify a valid module API name.

  • INVALID_MODULEHTTP 400

    The given module is not supported in API
    Resolution: The modules such as Documents and Projects are not supported in the current API. (This error will not be shown, once these modules are been supported). Specify a valid module API name.

  • 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 ZohoCRM.modules.attachments.CREATE scope. Create a new client with valid scope. Refer to scope section above.

  • NO_PERMISSIONHTTP 403

    Permission denied to upload attachment
    Resolution: The user does not have permission to upload attachments. 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 upload attachments
    Resolution: The user does not have the permission to upload attachments. Contact your system administrator.

  • INVALID_DATAHTTP 400

    the related id given seems to be invalid
    Resolution: The related record ID specified in the URL is invalid. Refer to Get Related Records API to get valid related record IDs.

  • INVALID_DATAHTTP 415

    invalid file type
    Resolution: The attachment that you are trying to upload is of an unsupported file form (.exe).

  • FILE_SIZE_MORE_THAN_ALLOWED_SIZEHTTP 415

    please check if the file size is in the correct range
    Resolution: The attachment you are trying to upload exceeds the allowed size(100 MB). Ensure that the attachment being uploaded is within the prescribed range.

Sample Response

Copied{
  "data": [
    {
      "code": "SUCCESS",
      "details": {
        "Modified_Time": "2021-05-05T05:33:33+00:00",
        "Modified_By": {
          "name": "Patricia Boyle",
          "id": "738964000000291009"
        },
        "Created_Time": "2021-05-05T05:33:33+00:00",
        "id": "738964000002118002",
        "Created_By": {
          "name": "Patricia Boyle",
          "id": "738964000000291009"
        }
      },
      "message": "attachment uploaded successfully",
      "status": "success"
    }
  ]
}