> You are reading the Docusign Developer Documentation. For clean Markdown of any page, append .md to the page URL. > > Documentation indexes by section: > - APIs and SDKs: https://docusign.docs.buildwithfern.com/docs/llms.txt > - Platform 101: https://docusign.docs.buildwithfern.com/platform/llms.txt > - Extension Apps: https://docusign.docs.buildwithfern.com/extension-apps/llms.txt > - Docusign CLI: https://docusign.docs.buildwithfern.com/docusign-cli/llms.txt > > Authentication (OAuth, JWT Grant, M2M): https://docusign.docs.buildwithfern.com/platform/auth > Webhooks and Connect: https://docusign.docs.buildwithfern.com/platform/webhooks > > OpenAPI specifications: https://docusign.docs.buildwithfern.com/openapi.json > MCP server: https://docusign.docs.buildwithfern.com/_mcp/server # How to require ID verification (IDV) for a recipient > This topic demonstrates how to request a signature via email while also using ID verification (IDV) authentication. eSignature REST API 2.1 only This topic demonstrates how to request a signature via email while also using [ID verification](/docs/esign-rest-api/esign101/concepts/recipients/auth#idv) authentication. > **Note** > > Run this code example from our [Quickstart](/docs/esign-rest-api/quickstart) or launcher projects: [Bash](https://github.com/docusign/code-examples-bash), [C#](https://github.com/docusign/code-examples-csharp), [Java](https://github.com/docusign/code-examples-java), [Node.js](https://github.com/docusign/code-examples-node), [PHP](https://github.com/docusign/code-examples-php), [PowerShell](https://github.com/docusign/code-examples-powershell), [Python](https://github.com/docusign/code-examples-python), or [Ruby](https://github.com/docusign/code-examples-ruby). ## Required data Running the code in this how-to requires this data: | Data element | Description | | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | \{API_ACCOUNT_ID} | A [GUID](http://guid.one/) value that identifies your account. This value is automatically generated by Docusign for any account you create. Copy the value from the **API Account ID** field on the [Apps and Keys](https://admindemo.docusign.com/authenticate?goTo=appsAndKeys) page. | | \{BASE_PATH} | A string value that forms the root of the URL required to make API calls. The base path value in the example code is set to target the developer environment at https\://\/restapi Where \ is demo.docusign.net for the developer environment and is the result of the GetUserInfo call in production. | | \{RECIPIENT_ID} | A unique string value that you assign to identify each recipient. This value assigns tabs on a per-[recipient](/docs/esign-rest-api/esign101/concepts/recipients) basis. | | \{SIGNER_EMAIL} | A string value for the email address where the signer will receive a notification of the signing request. | | \{SIGNER_NAME} | A string value for the full name of the signer. | | \{WORKFLOW_ID} | A [GUID](http://guid.one/) value that identifies the ID verification workflow assigned to your account when IDV is enabled. | ## Step 1. Obtain your OAuth token To make the API calls shown in this how-to, you need a valid OAuth access token. Docusign supports access tokens for three different recommended OAuth grant types: Public Authorization Code Grant, Confidential Authorization Code Grant, and JSON Web Token (JWT) Grant. Choose the OAuth grant type appropriate for your scenario. > **Note** > > See [Confidential Authorization Code Grant](/platform/auth/authcode#confidential-authorization-code-grant) for guidance on your options to get an Confidential Authorization Code Grant OAuth token. ![Three icons that represent the three methods a user can use to obtain an OAuth token: JSON Web Token (JWT), Public Authorization Code Grant (ACG), and Confidential Authorization Code grant](/_fern-files/_img/64f473773042ee439449a096bf7673292b1585b86a4ccc55f82ba0dda41f61a1.webp) ## Step 2. Construct your API headers After you have a valid OAuth access token, you are ready to construct the API headers that you will pass to the API call. Construct your headers like this, but make sure to substitute your valid OAuth access token for \{ACCESS_TOKEN}. **`Bash`** ```bash title="Bash" declare -a Headers=('--header' "Authorization: Bearer ${ACCESS_TOKEN}" \ '--header' "Accept: application/json" \ '--header' "Content-Type: application/json") ``` **`C#`** ```csharp title="C#" var docuSignClient = new DocuSignClient(basePath); docuSignClient.Configuration.DefaultHeader.Add("Authorization", "Bearer " + accessToken); ``` **`Java`** ```java title="Java" ApiClient apiClient = new ApiClient(basePath); apiClient.addDefaultHeader(HttpHeaders.AUTHORIZATION, BEARER_AUTHENTICATION + userAccessToken); ``` **`Node.js`** ```javascript title="Node.js" let dsApiClient = new docusign.ApiClient(); dsApiClient.setBasePath(args.basePath); dsApiClient.addDefaultHeader('Authorization', 'Bearer ' + args.accessToken); ``` **`PHP`** ```php title="PHP" $config = new Configuration(); $config->setHost($args['base_path']); $config->addDefaultHeader('Authorization', 'Bearer ' . $args['ds_access_token']); $this->apiClient = new ApiClient($config); ``` **`PowerShell`** ```text title="PowerShell" $headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]" $headers.add("Authorization", "Bearer $oAuthAccessToken") $headers.add("Accept", "application/json, text/plain, */*") $headers.add("Content-Type", "application/json;charset=UTF-8") $headers.add("Accept-Encoding", "gzip, deflate, br") $headers.add("Accept-Language", "en-US,en;q=0.9") ``` **`Python`** ```python title="Python" api_client = create_api_client(base_path=args["base_path"], access_token=args["access_token"]) ``` **`Ruby`** ```ruby title="Ruby" configuration = DocuSign_eSign::Configuration.new configuration.host = args[:base_path] api_client = DocuSign_eSign::ApiClient.new configuration api_client.default_headers['Authorization'] = "Bearer #{args[:access_token]}" ``` ## Step 3. Obtain your workflow ID To configure recipient authentication for IDV, you must provide your workflow ID in the request body. Call the [IdentityVerifications:list](/docs/esign-rest-api/reference/accounts/identityverifications/list) endpoint using your \{API_ACCOUNT_ID} to retrieve the workflow ID. Different workflow IDs can be specified per recipient. If you do not have IDV configured for your account, the `identity_verification` call will return an empty array. Omitting a workflow ID or providing an invalid workflow ID will cause your IDV request to fail. **`Bash`** ```bash title="Bash" echo "" echo "Attempting to retrieve your account's workflow ID" echo "" response=$(mktemp /tmp/response-bs.XXXXXX) Status=$(curl -w '%{http_code}' -i --request GET "https://demo.docusign.net/restapi/v2.1/accounts/${account_id}/identity_verification" \ "${Headers[@]}" \ --output ${response}) #If the Status code returned is greater than 201 (OK / Accepted), display an error message along with the API response. if [[ "$Status" -gt "201" ]] ; then echo "" echo "Unable to retrieve your account's workflow ID." echo "" cat $response exit 0 fi echo "" echo "Response:" cat $response echo "" # Retrieve the workflow IDs from the API response and put them in an array. workflowIds=`cat $response | grep -o -P '(?<=workflowId\":\").*?(?=\")'` # Get the index of the default workflow based on name and use that index for workflowId. # Workflow name of the default workflow is 'DocuSign ID Verification' workflowNames=`cat $response | grep -o -P '(?<=defaultName\":).*?(?=,)'` element="DocuSign ID Verification" workflowId=$(GetWorkflowId "$workflowNames" "$element" "$workflowIds") ``` **`C#`** ```csharp title="C#" var accountsApi = new AccountsApi(docuSignClient); var response = accountsApi.GetAccountIdentityVerificationWithHttpInfo(accountId); response.Headers.TryGetValue("X-RateLimit-Remaining", out string remaining); response.Headers.TryGetValue("X-RateLimit-Reset", out string reset); if (reset != null && remaining != null) { DateTime resetDate = DateTimeOffset.FromUnixTimeSeconds(long.Parse(reset)).UtcDateTime; Console.WriteLine("API calls remaining: " + remaining); Console.WriteLine("Next Reset: " + resetDate); } var phoneAuthWorkflow = response.Data.IdentityVerification.FirstOrDefault(x => x.DefaultName == "DocuSign ID Verification"); ``` **`Java`** ```java title="Java" AccountsApi workflowDetails = new AccountsApi(apiClient); var workflowRes = workflowDetails.getAccountIdentityVerificationWithHttpInfo(accountId, workflowDetails.new GetAccountIdentityVerificationOptions()); Map> headers = workflowRes.getHeaders(); java.util.List remaining = headers.get("X-RateLimit-Remaining"); java.util.List reset = headers.get("X-RateLimit-Reset"); if (remaining != null & reset != null) { Instant resetInstant = Instant.ofEpochSecond(Long.parseLong(reset.get(0))); System.out.println("API calls remaining: " + remaining); System.out.println("Next Reset: " + resetInstant); } List identityVerification = workflowRes.getData() .getIdentityVerification(); String workflowId = ""; for (int i = 0; i < identityVerification.size(); i++) { if (identityVerification.get(i).getDefaultName().equals("DocuSign ID Verification")) { workflowId = identityVerification.get(i).getWorkflowId(); } } return workflowId; ``` **`Node.js`** ```javascript title="Node.js" let accountsApi = new docusign.AccountsApi(dsApiClient); let workflowId = null; let results = await accountsApi.getAccountIdentityVerification( args.accountId, (error, data, response) => { const headers = response?.headers; const remaining = headers?.['x-ratelimit-remaining']; const reset = headers?.['x-ratelimit-reset']; if (remaining && reset) { const resetInstant = new Date(Number(reset) * 1000); console.log(`API calls remaining: ${remaining}`); console.log(`Next Reset: ${resetInstant.toISOString()}`); } }); // Find the workflow ID corresponding to the name "DocuSign ID Verification" results.data.identityVerification.forEach(workflow => { if (workflow.defaultName === 'DocuSign ID Verification') { workflowId = workflow.workflowId; } }); ``` **`PHP`** ```php title="PHP" $accounts_api = $clientService->getAccountsApi(); $accounts_response = $accounts_api->getAccountIdentityVerificationWithHttpInfo($_SESSION['ds_account_id']); $remaining = $accounts_response[2]['X-RateLimit-Remaining'] ?? null; $reset = $accounts_response[2]['X-RateLimit-Reset'] ?? null; if ($remaining !== null && $reset !== null) { $resetInstant = (new DateTime())->setTimestamp((int)$reset); error_log("API calls remaining: $remaining"); error_log("Next Reset: " . $resetInstant->format(\DateTime::ATOM)); } $workflows_data = $accounts_response[0]->getIdentityVerification(); $workflow_id = ''; foreach ($workflows_data as $workflow) { if ($workflow['default_name'] == 'DocuSign ID Verification') { $workflow_id = $workflow['workflow_id']; } } ``` **`PowerShell`** ```text title="PowerShell" $uri = "https://demo.docusign.net/restapi/v2.1/accounts/$APIAccountId/identity_verification" Write-Output "Attempting to retrieve your account's workflow ID" Write-Output "Response:" $result = Invoke-RestMethod -uri $uri -headers $headers -method GET $result.content #Obtain the workflow ID from the API response $workflowId = [System.Linq.Enumerable]::FirstOrDefault($result.identityVerification, [func[object, bool]] { param($x) $x.defaultName -eq "DocuSign ID Verification"}).workflowId ``` **`Python`** ```python title="Python" workflow_details = AccountsApi(api_client) (workflow_response, status, headers) = workflow_details.get_account_identity_verification_with_http_info(account_id=args["account_id"]) remaining = headers.get("X-RateLimit-Remaining") reset = headers.get("X-RateLimit-Reset") if remaining is not None and reset is not None: reset_date = dt.fromtimestamp(int(reset), tz=timezone.utc) print(f"API calls remaining: {remaining}") print(f"Next Reset: {reset_date}") # Check that idv authentication is enabled if workflow_response.identity_verification: # Find the workflow ID corresponding to the name "DocuSign ID Verification" workflow_id = None for workflow in workflow_response.identity_verification: if workflow.default_name == "DocuSign ID Verification": workflow_id = workflow.workflow_id break if workflow_id is not None: app.logger.info("We found the following workflowID: " + workflow_id) else: app.logger.info("No workflowID was found for DocuSign ID Verification.") session['workflow_id'] = workflow_id return workflow_id else: return None ``` **`Ruby`** ```ruby title="Ruby" accounts_api = create_account_api(args) workflow_response, _status, headers = accounts_api.get_account_identity_verification_with_http_info args[:account_id] remaining = headers['X-RateLimit-Remaining'] reset = headers['X-RateLimit-Reset'] if remaining && reset reset_date = Time.at(reset.to_i).utc puts "API calls remaining: #{remaining}" puts "Next Reset: #{reset_date}" end if workflow_response.identity_verification idv_workflow = workflow_response.identity_verification.find { |item| item.default_name == 'DocuSign ID Verification' } workflow_id = idv_workflow.workflow_id if idv_workflow end ``` ## Step 4. Construct the request body Next, create the request body. Replace \{RECIPIENT_ID}, \{SIGNER_NAME}, \{SIGNER_EMAIL}, and \{WORKFLOW_ID} with your recipient's data in the JSON request body. **Note:** The sample code provided uses fixed positioning for the `signHere` tab. If your Docusign account has **Document Visibility** enabled (via **Sending Settings** in eSignature Admin), and you have not placed a tab for each signer, you will receive this [API error](https://support.docusign.com/s/articles/Free-Form-Signing-Not-Allowed-When-Document-Visibility-is-On?rsc_301): "Freeform signing is not allowed for your account because it conflicts with other settings, please place fields for each signer." **Tip:** The example Base64-encoded document shown here is a generic sample that you can copy and paste into your own code for testing. There are many free online Base64 encoders/decoders, such as [FreeFormatter.com](https://www.freeformatter.com/base64-encoder.html), that you can use to encode the `documentBase64` property. **`Bash`** ```bash title="Bash" printf \ '{ "documents": [{ "documentBase64": "' > $request_data cat $doc_base64 >> $request_data printf '", "documentId": "1", "fileExtension": "txt", "name": "NDA" }], "emailBlurb": "Sample text for email body", "emailSubject": "Please Sign", "envelopeIdStamping": "true", "recipients": { "signers": [{ "name": "'"${RECIPIENT_NAME}"'", "email": "'"${RECIPIENT_EMAIL}"'", "roleName": "", "note": "", "routingOrder": 1, "status": "created", "tabs": { "signHereTabs": [{ "documentId": "1", "name": "SignHereTab", "pageNumber": "1", "recipientId": "1", "tabLabel": "SignHereTab", "xPosition": "200", "yPosition": "220" }] }, "templateAccessCodeRequired": null, "deliveryMethod": "email", "recipientId": "1", "identityVerification": { "workflowId": "'"${workflowId}"'", "steps": null }, "idCheckConfigurationName": "", "requireIdLookup": false }] }, "status": "Sent" } ' >> $request_data ``` **`C#`** ```csharp title="C#" EnvelopeDefinition env = new EnvelopeDefinition() { EnvelopeIdStamping = "true", EmailSubject = "Please Sign", EmailBlurb = "Sample text for email body", Status = "Sent", }; // Add a document Document doc1 = new Document() { DocumentBase64 = "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", DocumentId = "1", FileExtension = "pdf", Name = "Lorem", }; // Create your signature tab env.Documents = new List { doc1 }; SignHere signHere1 = new SignHere { Name = "SignHereTab", XPosition = "200", YPosition = "160", TabLabel = "SignHereTab", PageNumber = "1", DocumentId = "1", // A 1- to 8-digit integer or 32-character GUID to match recipient IDs on your own systems. // This value is referenced in the Tabs element below to assign tabs on a per-recipient basis. RecipientId = "1", // represents your {RECIPIENT_ID} }; // Tabs are set per recipient/signer Tabs signer1Tabs = new Tabs { SignHereTabs = new List { signHere1 }, }; RecipientIdentityVerification workflow = new RecipientIdentityVerification() { WorkflowId = workflowId, }; Signer signer1 = new Signer() { Name = signerName, Email = signerEmail, RoleName = string.Empty, Note = string.Empty, Status = "created", DeliveryMethod = "email", RecipientId = "1", // represents your {RECIPIENT_ID} IdentityVerification = workflow, Tabs = signer1Tabs, }; Recipients recipients = new Recipients(); recipients.Signers = new List { signer1 }; env.Recipients = recipients; ``` **`Java`** ```java title="Java" public static EnvelopeDefinition createEnvelope( String signerName, String signerEmail, String workflowId) { EnvelopeDefinition envelopeDefinition = new EnvelopeDefinition(); envelopeDefinition.setEmailSubject("Please sign"); envelopeDefinition.setEmailBlurb("Sample text for email body"); envelopeDefinition.setStatus("Sent"); byte[] fileBytes = new byte[0]; try { fileBytes = EnvelopeHelpers.readFile(DOCUMENT_FILE_NAME); } catch (IOException e) { e.printStackTrace(); } Document doc1 = new Document(); doc1.setDocumentBase64(Base64.getEncoder().encodeToString(fileBytes)); doc1.setDocumentId("1"); doc1.setFileExtension("pdf"); doc1.setName("Lorem"); SignHere signHere1 = new SignHere(); signHere1.setName("SignHereTab"); signHere1.setXPosition("75"); signHere1.setYPosition("572"); signHere1.setTabLabel("SignHereTab"); signHere1.setPageNumber("1"); signHere1.setDocumentId("1"); // A 1- to 8-digit integer or 32-character GUID to match recipient IDs on your // own systems. // This value is referenced in the Tabs element below to assign tabs on a // per-recipient basis. signHere1.setRecipientId("1"); // represents your {RECIPIENT_ID} Tabs signer1Tabs = new Tabs(); signer1Tabs.setSignHereTabs(Collections.singletonList(signHere1)); RecipientIdentityVerification workflow = new RecipientIdentityVerification(); workflow.setWorkflowId(workflowId); String status = "created"; String deliveryMethod = "email"; Signer signer1 = new Signer(); signer1.setName(signerName); signer1.setEmail(signerEmail); signer1.setRoleName(""); signer1.setNote(""); signer1.setStatus(status); signer1.setDeliveryMethod(deliveryMethod); signer1.setRecipientId("1"); // represents your {RECIPIENT_ID} signer1.setIdentityVerification(workflow); signer1.setTabs(signer1Tabs); Recipients recipients = new Recipients(); recipients.setSigners(Collections.singletonList(signer1)); envelopeDefinition.setRecipients(recipients); envelopeDefinition.setDocuments(Collections.singletonList(doc1)); return envelopeDefinition; } ``` **`Node.js`** ```javascript title="Node.js" let envelope = makeEnvelope(args.envelopeArgs); function makeEnvelope(args) { // Data for this method // args.signerEmail // args.signerName // docFile // document 1 (pdf) has tag /sn1/ // // The envelope has one recipients. // recipient 1 - signer let docPdfBytes; // read file from a local directory // The read could raise an exception if the file is not available! docPdfBytes = fs.readFileSync(args.docFile); // Create the envelope definition let env = new docusign.EnvelopeDefinition(); env.emailSubject = 'Please sign'; env.emailBlurb = 'Sample text for email body'; env.status = 'Sent'; // Add a document let doc1 = new docusign.Document(); let doc1b64 = Buffer.from(docPdfBytes).toString('base64'); doc1.documentBase64 = doc1b64; doc1.name = 'Lorem'; // can be different from actual file name doc1.fileExtension = 'pdf'; doc1.documentId = '1'; env.documents = [doc1]; // Create signHere fields (also known as tabs) on the documents, // We're using anchor (autoPlace) positioning let signHere1 = docusign.SignHere.constructFromObject({ anchorString: '/sn1/', anchorYOffset: '10', anchorUnits: 'pixels', anchorXOffset: '20', }); // Tabs are set per recipient / signer let signer1Tabs = docusign.Tabs.constructFromObject({ signHereTabs: [signHere1], }); // A 1- to 8-digit integer or 32-character GUID to match recipient IDs on your own systems. // This value is referenced in the Tabs element below to assign tabs on a per-recipient basis. RecipientId = '1'; // represents your {RECIPIENT_ID} let signer1 = docusign.Signer.constructFromObject({ email: args.signerEmail, name: args.signerName, recipientId: RecipientId, routingOrder: '1', deliveryMethod: 'Email', tabs: signer1Tabs, identityVerification: { workflowId: args.workflowId, steps: null }, }); // Add the recipient to the envelope object let recipients = docusign.Recipients.constructFromObject({ signers: [signer1], }); env.recipients = recipients; return env; } ``` **`PHP`** ```php title="PHP" $envelope_definition = $envelopeAndSigner['envelopeDefinition']; $signer1Tabs = $envelopeAndSigner['signerTabs']; $signer1 = new Signer( [ 'name' => $args['signer_name'], 'email' => $args['signer_email'], 'routing_order' => '1', 'status' => 'created', 'delivery_method' => 'Email', 'recipient_id' => '1', # Represents your {RECIPIENT_ID} 'tabs' => $signer1Tabs, ] ); $wFObj = new RecipientIdentityVerification(); $wFObj->setWorkflowId($workflow_id); $signer1->setIdentityVerification($wFObj); $recipients = new Recipients(); $recipients->setSigners(array($signer1)); $envelope_definition->setRecipients($recipients); ``` **`PowerShell`** ```text title="PowerShell" $body = @" { "documents": [{ "documentBase64": "$(Get-Content $docBase64)", "documentId": "1", "fileExtension": "pdf", "name": "Lorem" }], "emailBlurb": "Sample text for email body", "emailSubject": "Please Sign", "envelopeIdStamping": "true", "recipients": { "signers": [{ "name": "$SIGNER_NAME", "email": "$SIGNER_EMAIL", "routingOrder": 1, "status": "created", "tabs": { "signHereTabs": [{ "documentId": "1", "name": "SignHereTab", "pageNumber": "1", "recipientId":"1", "tabLabel": "SignHereTab", "xPosition": "200", "yPosition": "160" }] }, "templateAccessCodeRequired": null, "deliveryMethod": "email", "recipientId": "1", "identityVerification": { "workflowId": "$workflowId", "steps": null }, "idCheckConfigurationName": "", "requireIdLookup": false }] }, "status": "Sent" } "@ ``` **`Python`** ```python title="Python" envelope_definition = EnvelopeDefinition( email_subject="Please sign this document set" ) # Open the example file with open(path.join(demo_docs_path, DS_CONFIG["doc_pdf"]), "rb") as file: content_bytes = file.read() base64_file_content = base64.b64encode(content_bytes).decode("ascii") # Add a document document1 = Document( # create the DocuSign document object document_base64=base64_file_content, document_id="1", # a label used to reference the doc file_extension="pdf", # many different document types are accepted name="Lorem" # can be different from actual file name ) envelope_definition.documents = [document1] envelope_definition.status = args["envelope_args"]["status"] # Create your signature tab sign_here1 = SignHere( name="SignHereTab", x_position="200", y_position="160", tab_label="SignHereTab", page_number="1", document_id="1", # A 1- to 8-digit integer or 32-character GUID to match recipient IDs on your own systems. # This value is referenced in the Tabs element below to assign tabs on a per-recipient basis. recipient_id="1" # represents your {RECIPIENT_ID} ) signer1 = Signer( email=args["envelope_args"]["signer_email"], # Represents your {signer_email} name=args["envelope_args"]["signer_name"], # Represents your {signer_name} role_name="", note="", status="created", delivery_method="email", recipient_id="1", # Represents your {RECIPIENT_ID} routing_order="1", identity_verification={"workflowId": args["envelope_args"]["workflow_id"], "steps": "null"}, tabs=Tabs(sign_here_tabs=[sign_here1]) ) # Tabs are set per recipient envelope_definition.recipients = Recipients(signers=[signer1]) ``` **`Ruby`** ```ruby title="Ruby" envelope_definition = DocuSign_eSign::EnvelopeDefinition.new envelope_definition.email_subject = 'Please sign this document set' # Add the documents pdf_filename = 'World_Wide_Corp_lorem.pdf' # Create the document models document1 = DocuSign_eSign::Document.new( # Create the Docusign Document object documentBase64: Base64.encode64(File.binread(File.join('data', pdf_filename))), name: 'Lorem', # Can be different from the actual file name fileExtension: 'pdf', # Many different document types are accepted documentId: '1' # A label used to reference the doc ) envelope_definition.documents = [document1] # Create the signer recipient model signer1 = DocuSign_eSign::Signer.new signer1.email = envelope_args[:signer_email] signer1.name = envelope_args[:signer_name] signer1.recipient_id = '1' signer1.routing_order = '1' sign_here1 = DocuSign_eSign::SignHere.new sign_here1.anchor_string = '/sn1/' sign_here1.anchor_units = 'pixels' sign_here1.anchor_x_offset = '20' sign_here1.anchor_y_offset = '10' # Add the tabs model (including the sign_here tabs) to the signer # The Tabs object takes arrays of the different field/tab types signer1_tabs = DocuSign_eSign::Tabs.new({ signHereTabs: [sign_here1] }) signer1.tabs = signer1_tabs wf = DocuSign_eSign::RecipientIdentityVerification.new wf.workflow_id = workflow_id signer1.identity_verification = wf # Add the recipients to the Envelope object recipients = DocuSign_eSign::Recipients.new( signers: [signer1] ) # Request that the envelope be sent by setting status to "sent" # To request that the envelope be created as a draft, set status to "created" envelope_definition.recipients = recipients envelope_definition.status = envelope_args[:status] ``` ## Step 5. Call the eSignature REST API Now that you have constructed your API headers and request body, you can send the envelope with the [Envelopes:create](/docs/esign-rest-api/reference/envelopes/envelopes/create) method. Here’s how you make the call, but make sure to substitute your API account ID for \{ACCOUNT_ID}. > **Note** > > View the source code for this how-to on GitHub: [Bash](https://github.com/docusign/code-examples-bash/blob/master/examples/eSignature/eg023SigningViaEmailWithIDVAuthentication.sh), [C#](https://github.com/docusign/code-examples-csharp/blob/master/launcher-csharp/eSignature/Examples/RecipientAuthIDV.cs), [Java](https://github.com/docusign/code-examples-java/blob/master/src/main/java/com/docusign/controller/eSignature/services/IdvAuthenticationService.java), [Node.js](https://github.com/docusign/code-examples-node/blob/master/lib/eSignature/examples/idvAuthentication.js), [PHP](https://github.com/docusign/code-examples-php/blob/master/src/Services/Examples/eSignature/IDVAuthenticationService.php), [PowerShell](https://github.com/docusign/code-examples-powershell/blob/master/examples/eSignature/eg023SigningViaEmailWithIDVAuthentication.ps1), [Python](https://github.com/docusign/code-examples-python/blob/master/app/eSignature/examples/eg023_idv_authentication.py), or [Ruby](https://github.com/docusign/code-examples-ruby/blob/master/app/services/e_sign/eg023_idv_authentication_service.rb). **`Bash`** ```bash title="Bash" curl --request POST "https://demo.docusign.net/restapi/v2.1/accounts/${account_id}/envelopes" \ "${Headers[@]}" \ --data-binary @${request_data} \ --output ${response} ``` **`C#`** ```csharp title="C#" EnvelopesApi envelopesApi = new EnvelopesApi(docuSignClient); var results = envelopesApi.CreateEnvelopeWithHttpInfo(accountId, env); results.Headers.TryGetValue("X-RateLimit-Remaining", out remaining); results.Headers.TryGetValue("X-RateLimit-Reset", out reset); if (reset != null && remaining != null) { DateTime resetDate = DateTimeOffset.FromUnixTimeSeconds(long.Parse(reset)).UtcDateTime; Console.WriteLine("API calls remaining: " + remaining); Console.WriteLine("Next Reset: " + resetDate); } ``` **`Java`** ```java title="Java" EnvelopeSummary results = IdvAuthenticationService.idvAuthentication(envelopesApi, session.getAccountId(), envelope); ``` **`Node.js`** ```javascript title="Node.js" let envelopesApi = new docusign.EnvelopesApi(dsApiClient); results = await envelopesApi.createEnvelope(args.accountId, { envelopeDefinition: envelope, }, (error, data, response) => { const headers = response?.headers; const remaining = headers?.['x-ratelimit-remaining']; const reset = headers?.['x-ratelimit-reset']; if (remaining && reset) { const resetInstant = new Date(Number(reset) * 1000); console.log(`API calls remaining: ${remaining}`); console.log(`Next Reset: ${resetInstant.toISOString()}`); } }); ``` **`PHP`** ```php title="PHP" $envelope_api = $clientService->getEnvelopeApi(); $envelopeResponse = $envelope_api->createEnvelopeWithHttpInfo( $args['account_id'], $envelope_definition ); $remaining = $envelopeResponse[2]['X-RateLimit-Remaining'] ?? null; $reset = $envelopeResponse[2]['X-RateLimit-Reset'] ?? null; if ($remaining !== null && $reset !== null) { $resetInstant = (new DateTime())->setTimestamp((int)$reset); error_log("API calls remaining: $remaining"); error_log("Next Reset: " . $resetInstant->format(\DateTime::ATOM)); } return ['envelope_id' => $envelopeResponse[0]->getEnvelopeId()]; ``` **`PowerShell`** ```text title="PowerShell" $uri = "https://demo.docusign.net/restapi/v2.1/accounts/$APIAccountId/envelopes" try { Write-Output "Response:" $result = Invoke-WebRequest -uri $uri -headers $headers -body $body -method POST $response = $result.content | ConvertFrom-Json $envelopeId = $response.envelopeId # Save the IDV envelope id for use by other scripts Write-Output "IDV EnvelopeId: " $envelopeId Write-Output $envelopeId > .\config\IDV_ENVELOPE_ID } catch { $int = 0 foreach ($header in $_.Exception.Response.Headers) { if ($header -eq "X-DocuSign-TraceToken") { Write-Output "TraceToken : " $_.Exception.Response.Headers[$int] } $int++ } Write-Output "Error : "$_.ErrorDetails.Message Write-Output "Command : "$_.InvocationInfo.Line } ``` **`Python`** ```python title="Python" envelopes_api = EnvelopesApi(api_client) (results, status, headers) = envelopes_api.create_envelope_with_http_info(account_id=args["account_id"], envelope_definition=envelope_definition) remaining = headers.get("X-RateLimit-Remaining") reset = headers.get("X-RateLimit-Reset") if remaining is not None and reset is not None: reset_date = dt.fromtimestamp(int(reset), tz=timezone.utc) print(f"API calls remaining: {remaining}") print(f"Next Reset: {reset_date}") ``` **`Ruby`** ```ruby title="Ruby" envelope_api = create_envelope_api(args) results, _status, headers = envelope_api.create_envelope_with_http_info args[:account_id], envelope_definition remaining = headers['X-RateLimit-Remaining'] reset = headers['X-RateLimit-Reset'] if remaining && reset reset_date = Time.at(reset.to_i).utc puts "API calls remaining: #{remaining}" puts "Next Reset: #{reset_date}" end ``` ## Expected response If you run this code example from our Quickstart or launcher projects, you should see a JSON response similar to the code shown. **`Sample response`** ```json title="Sample response" { "envelopeId": "4e5e1569-xxxx-xxxx-xxxx-f18fc5609b48", "uri": "/envelopes/4e5e1569-xxxx-xxxx-xxxx-f18fc5609b48", "statusDateTime": "2020-08-04T00:15:50.1300000Z", "status": "sent" } ``` ## Next steps * Run this code example from our [Quickstart](/docs/esign-rest-api/quickstart) or launcher projects: [Bash](https://github.com/docusign/code-examples-bash), [C#](https://github.com/docusign/code-examples-csharp), [Java](https://github.com/docusign/code-examples-java), [Node.js](https://github.com/docusign/code-examples-node), [PHP](https://github.com/docusign/code-examples-php), [PowerShell](https://github.com/docusign/code-examples-powershell), [Python](https://github.com/docusign/code-examples-python), or [Ruby](https://github.com/docusign/code-examples-ruby). * See [tabs](/docs/esign-rest-api/esign101/concepts/tabs) for context around tabs and your options for setting them. * See [recipient authentication](/docs/esign-rest-api/esign101/concepts/recipients/auth) for details about the feature. * See how to [Go-Live](/docs/esign-rest-api/go-live) with a completed app and find the base path for API calls in the production environment.