DocuSign Integration: API, Embedded Signing & Webhook Setup

Our company is engaged in the development, support and maintenance of sites of any complexity. From simple one-page sites to large-scale cluster systems built on micro services. Experience of developers is confirmed by certificates from vendors.

Development and maintenance of all types of websites:

Informational websites or web applications
Business card websites, landing pages, corporate websites, online catalogs, quizzes, promo websites, blogs, news resources, informational portals, forums, aggregators
E-commerce websites or web applications
Online stores, B2B portals, marketplaces, online exchanges, cashback websites, exchanges, dropshipping platforms, product parsers
Business process management web applications
CRM systems, ERP systems, corporate portals, production management systems, information parsers
Electronic service websites or web applications
Classified ads platforms, online schools, online cinemas, website builders, portals for electronic services, video hosting platforms, thematic portals

These are just some of the technical types of websites we work with, and each of them can have its own specific features and functionality, as well as be customized to meet the specific needs and goals of the client.

Showing 1 of 1All 2062 services
DocuSign Integration: API, Embedded Signing & Webhook Setup
Medium
~3-5 days
Frequently Asked Questions

Our competencies:

Development stages

Latest works

  • image_website-b2b-advance_0.webp
    B2B ADVANCE company website development
    1358
  • image_web-applications_feedme_466_0.webp
    Development of a web application for FEEDME
    1250
  • image_websites_belfingroup_462_0.webp
    Website development for BELFINGROUP
    956
  • image_ecommerce_furnoro_435_0.webp
    Development of an online store for the company FURNORO
    1188
  • image_crm_enviok_479_0.webp
    Development of a web application for Enviok
    929
  • image_bitrix-bitrix-24-1c_fixper_448_0.webp
    Website development for FIXPER company
    947

Integrating DocuSign integration with a web application for electronic signature on website often encounters OAuth errors, incorrect anchor strings, or misconfigured webhooks. Typical issues include misconfigured redirect URIs, outdated SDK versions, and mismatched PDF tags. All this leads to runtime failures and lost deals. We specialize in such DocuSign API integration: we have completed over 30 projects where DocuSign is used for signing contracts, acts, and invoices. On average, our clients reduce document processing time by 40% and accelerate deal closure by 3 times. Embedded signing via DocuSign API improves completion rate by 3x compared to email signing, saving up to $1,500 per month in manual processing costs.

Why Choose DocuSign?

DocuSign is the market leader in electronic signatures in the US and Europe. It supports legally binding signatures under eIDAS (Europe), UETA/ESIGN (USA), and several national standards. For the Russian market: DocuSign provides a simple electronic signature (SES) that is recognized in court if there is an agreement between the parties—this is sufficient for most commercial contracts. For more details, see the Official DocuSign documentation.

How Integration Works?

Typical flow:

  1. User fills in data on the website → clicks "Sign contract"
  2. Backend creates an Envelope in DocuSign with the document and recipients
  3. User is redirected to DocuSign to sign (or receives an email)
  4. After signing, DocuSign notifies the site via webhook
  5. Backend downloads the signed document and saves it

We implement two scenarios: email sending or embedded signing—signing directly on the site. Comparison:

Criteria Email Signing Embedded Signing
Interaction User goes to DocuSign Signing in iframe on your site
UX Control Minimal Full (design, redirect)
Completion Rate ~70% ~95% (3x fewer drop-offs)
Implementation Speed 2-3 days 4-5 days

Application Setup

In DocuSign Developer Portal: create Integration Key → add redirect URI → request Secret Key. For testing—free Demo environment (account-d.docusign.com).

composer require docusign/esign-client

OAuth: Obtaining a Token

DocuSign uses OAuth 2.0 Authorization Code Grant:

class DocuSignAuthService
{
    public function getAuthUrl(): string
    {
        $params = http_build_query([
            'response_type' => 'code',
            'scope'         => 'signature',
            'client_id'     => config('docusign.integrator_key'),
            'redirect_uri'  => config('docusign.redirect_uri'),
        ]);
        return 'https://account-d.docusign.com/oauth/auth?' . $params;
    }

    public function handleCallback(string $code): string
    {
        $response = Http::withBasicAuth(
            config('docusign.integrator_key'),
            config('docusign.client_secret')
        )->asForm()->post('https://account-d.docusign.com/oauth/token', [
            'grant_type'   => 'authorization_code',
            'code'         => $code,
            'redirect_uri' => config('docusign.redirect_uri'),
        ]);
        return $response->json('access_token');
    }
}

For server-side scenarios without user interaction—JWT Grant (service account).

Creating an Envelope and Sending for Signature

class DocuSignEnvelopeService
{
    public function createEnvelope(
        string $accessToken,
        string $pdfPath,
        array $signers
    ): string {
        $config = new \DocuSign\eSign\Configuration();
        $config->setHost(config('docusign.base_url'));
        $config->addDefaultHeader('Authorization', "Bearer {$accessToken}");

        $apiClient      = new \DocuSign\eSign\client\ApiClient($config);
        $envelopesApi   = new \DocuSign\eSign\Api\EnvelopesApi($apiClient);

        $document = new \DocuSign\eSign\Model\Document([
            'document_base64' => base64_encode(file_get_contents($pdfPath)),
            'name'            => 'Contract',
            'file_extension'  => 'pdf',
            'document_id'     => '1',
        ]);

        $signHere = new \DocuSign\eSign\Model\SignHere([
            'anchor_string'  => '/sig1/',
            'anchor_x_offset' => '20',
            'anchor_y_offset' => '-10',
            'anchor_units'   => 'pixels',
        ]);

        $recipientList = [];
        foreach ($signers as $i => $signer) {
            $tabs = new \DocuSign\eSign\Model\Tabs(['sign_here_tabs' => [$signHere]]);
            $recipientList[] = new \DocuSign\eSign\Model\Signer([
                'email'        => $signer['email'],
                'name'         => $signer['name'],
                'recipient_id' => (string)($i + 1),
                'routing_order'=> (string)($i + 1),
                'tabs'         => $tabs,
            ]);
        }

        $envelopeDefinition = new \DocuSign\eSign\Model\EnvelopeDefinition([
            'email_subject' => 'Please sign the document',
            'documents'     => [$document],
            'recipients'    => new \DocuSign\eSign\Model\Recipients([
                'signers' => $recipientList,
            ]),
            'status' => 'sent',
        ]);

        $result = $envelopesApi->createEnvelope(
            config('docusign.account_id'),
            $envelopeDefinition
        );

        return $result->getEnvelopeId();
    }
}

Embedded Signing: Signature Directly on the Site

Instead of redirecting to DocuSign—embedded iframe or redirect back to site:

public function getSigningUrl(string $accessToken, string $envelopeId, array $signer): string
{
    $config = new \DocuSign\eSign\Configuration();
    $config->setHost(config('docusign.base_url'));
    $config->addDefaultHeader('Authorization', "Bearer {$accessToken}");

    $apiClient    = new \DocuSign\eSign\client\ApiClient($config);
    $envelopesApi = new \DocuSign\eSign\Api\EnvelopesApi($apiClient);

    $viewRequest = new \DocuSign\eSign\Model\RecipientViewRequest([
        'authentication_method' => 'none',
        'client_user_id'        => $signer['id'],
        'recipient_id'          => '1',
        'return_url'            => route('contracts.signed'),
        'user_name'             => $signer['name'],
        'email'                 => $signer['email'],
    ]);

    $result = $envelopesApi->createRecipientView(
        config('docusign.account_id'),
        $envelopeId,
        $viewRequest
    );

    return $result->getUrl();
}

Webhook: Notification of Signing

After signing, DocuSign sends XML with the new status. The server must process the request, verify that the status is Completed, and start downloading the document. We set up an endpoint that accepts POST requests and ensure it is accessible from the outside world. In production, HTTPS is mandatory.

Common Integration Errors

Most common errors:

  • OAuth error: incorrect redirect URI or scope. Ensure the exact URI (including protocol and port) is specified in the app settings.
  • Anchor string mismatch: if the PDF document does not contain the specified anchor string, DocuSign will throw an error. Use tags like /sig1/ inside the original document.
  • Lost webhook: during testing, ensure the server is accessible from the external network (not localhost) and that DocuSign can send the request. In production, use HTTPS.

If you encounter these issues—our team can resolve them promptly.

What's Included in Our Integration Service

  • Analysis of business processes and selection of the optimal scenario (email/embedded)
  • DocuSign app setup (Integration Key, Secret, Redirect URI)
  • API integration development: envelope creation, signing management
  • Webhook integration for automatic status updates
  • Embedded signing: iframe setup with custom settings
  • Testing in demo environment and migration to production
  • Operational documentation (admin instructions)
  • Employee training on the new system
  • Ongoing support after launch

We guarantee stable operation and timely support after launch. Contact us to discuss your project and find the best solution.

Our Experience and Results

We are a team with experience in DocuSign API integration. We have completed over 30 projects for companies in fintech, logistics, and retail. One client—a commercial real estate rental platform—reduced contract signing time from 3 days to 2 hours, and courier delivery costs dropped by 80%. Another project—a B2B e-commerce store—increased order processing speed by 60% thanks to automatic signing of payment invoices. The average time savings on document workflow is 40%, and the conversion of deal closing increases by 3 times. With savings up to $1,500 per month, our clients see rapid ROI.

Want the same results? Get a consultation—we will evaluate your system and propose an implementation plan.

Timeframes

Basic integration (envelope creation + email to signer + webhook): 2–3 business days. Embedded signing with full in-site flow and automatic document download: 4–5 business days. The estimate includes DocuSign app registration, testing in demo environment, and production migration.

Ready to discuss your project? Contact us for a detailed audit of your document workflow system. We will select the optimal solution for your budget and timeline.

Website CRM Integration: Bitrix24, amoCRM, Salesforce, HubSpot

A sales manager manually copies leads from email into the CRM. Half of them never make it. Follow‑up calls are missed. This isn’t a people problem — it’s an architectural gap between the website and the company’s core system. We close that gap with a direct site‑to‑CRM connection: leads land in the pipeline within 30 seconds after form submission, duplication is blocked, and status changes flow both ways automatically. Request a free integration audit to identify the bottlenecks in your current flow.

Integration isn’t just a POST to an API endpoint. It’s a battle against timeouts, duplicate records, data loss, and desynchronised states. We handle three core problems at once: asynchronous delivery (so the user never waits for the CRM), deduplication by email (one address – one lead), and two‑way feedback (a status change in the CRM instantly appears on the site). Below is how we tackle each.

Bitrix24: REST API and Event Handlers

Bitrix24 dominates the Russian B2B space. Its REST API works via OAuth 2.0 or an incoming webhook (webhook is simpler but less secure for production). Main entities are lead, deal, contact, and company.

Creating a lead requires POST /rest/crm.lead.add with the correct field set. Attaching it to a funnel means passing SOURCE_ID. Adding a timeline comment uses crm.timeline.comment.add. Real‑time tracking is done through Event Handlers: register a hook with event.bind; Bitrix24 pushes a POST to your endpoint when any deal status changes.

The real complexity lies in custom fields. Every Bitrix24 installation has its own set, and their IDs must be fetched via crm.lead.fields. Mapping those fields between the site and the CRM can be done manually or automatically — we use an automatic detection mechanism that works even in non‑standard configurations (proven on 20+ projects). We guarantee correct matching, so no lead arrives without the right pipeline stage or source tag.

amoCRM: Clean REST with Predictable Endpoints

amoCRM (now Kommo for international markets) offers a cleaner API. OAuth 2.0 with refresh token, JSON API, and well‑structured endpoints. Pipelines are pipelines, deals are leads, contacts are contacts.

A common mistake: when creating a deal you must supply pipeline_id and status_id explicitly. Without them the deal lands in the default pipeline – often the wrong one. Tags for source classification go into _embedded.tags. Incoming webhooks are configured in the admin panel; they support add, update, delete, status, and note events. We always verify the webhook signature using the API key and make sure the endpoint responds with 200 OK in under 5 seconds – otherwise the CRM marks delivery as failed.

Salesforce and HubSpot: Enterprise‑Grade Integration

Salesforce is the enterprise standard. It offers REST API, SOQL for complex queries, and Apex for server‑side logic. Integration can be direct via Salesforce REST API or through middleware like Zapier or MuleSoft. For PHP projects we use phpforce/soap-client or the Force.com‑Toolkit. The main challenge is mapping hundreds of custom objects and fields; we solve it with Describe Global to collect metadata automatically – cutting setup time by three‑quarters compared to reading documentation manually (Salesforce Developer Guide).

HubSpot is popular among SaaS companies and international B2B. Its API v3 provides a REST interface with solid SDKs for PHP and Node.js (@hubspot/api-client). Contacts, Companies, Deals are standard objects. The Forms API lets you send data from any custom form directly to HubSpot without using the native widget. One pitfall: the access_token must include the right scopes; a misconfigured token returns 403 Forbidden with a vague message. We include error_logging that captures the error code – debugging takes minutes instead of hours.

Which CRM fits your business: Bitrix24, amoCRM, or HubSpot?

Criteria Bitrix24 amoCRM HubSpot
API complexity Medium (REST + webhooks, custom fields) Low (clean JSON API) Medium (REST + SDK, OAuth 2.0)
Typical synchronous latency 200‑600 ms 100‑300 ms 150‑400 ms
Built‑in deduplication by email crm.duplicate.findByComm Contact search contacts/search
Webhook events Event Handlers (push) Admin panel configuration Webhook + Automations
Best suited for Russian B2B, government, custom fields Small‑ to medium‑sized business International B2B, SaaS

Why is asynchronous sending important?

Calling a CRM API synchronously from the form handler is a mistake. The API may respond in 2 seconds – or time out. The user sits waiting. The correct pattern: form submission → save to database → queue a job → return 200 to the user immediately. A background worker then pushes the lead to the CRM. If the CRM is down, the worker retries with exponential backoff. We use Redis + Bull on Node.js or Laravel Queue on PHP – this guarantees delivery even during temporary outages.

Deduplication – how we stop duplicate leads

The same contact may fill the form twice. Without deduplication the CRM ends up with two identical leads. Before creating a new lead we search by email: for Bitrix24 we call crm.duplicate.findByComm, for HubSpot we use contacts/search. If a match is found we attach a task or comment to the existing lead instead of creating a new one. In our projects this cuts duplicate entries by 95%.

Two‑way synchronization – what happens when a manager changes a deal status

If a manager updates a deal status in the CRM, the website needs to reflect that change – especially if the client has a personal account. We configure webhooks from the CRM to an endpoint on the site, then update the local database and notify the client. Critical details: verify the webhook signature and respond with 200 OK within 5 seconds, otherwise the CRM assumes delivery failed. We guarantee that the delay between a status change in the CRM and its appearance on the site never exceeds 3 seconds.

How do we conduct integration in 5 steps?

  1. Audit of data flows – analyse current lead transfer, CRM field structure, and performance bottlenecks. Deliverable: “as‑is” and “to‑be” data flow diagrams.
  2. Architecture design – choose the queue mechanism (Redis Bull or Laravel Queue), define the deduplication method, and prepare a field mapping specification.
  3. Implementation on staging – write code on Laravel or Node.js, configure webhooks, and test with real data: lead creation, status updates, and error handling.
  4. Load testing – simulate peak traffic (e.g. 500 requests per minute) and adjust retry policies and timeout settings.
  5. Deployment and documentation – push to production, train the team on monitoring and retry cleanup, and deliver full endpoint documentation.

What is included in the work

  • Audit report with current data flow diagrams and typical error patterns.
  • Architecture design document specifying queue, deduplication, and mapping.
  • Production‑ready integration code on Laravel or Node.js.
  • Webhook configuration and signature verification.
  • Team training on support tasks and retry cleanup.
  • 30‑day warranty support for bug fixes and mapping adjustments.

Real‑world case: real‑estate agency with 400 leads per month

Click to expand A real‑estate agency processed every incoming lead manually – 400 leads per month. Each lead took 3 minutes to enter, and 15% were lost because emails were missed. We integrated their site with amoCRM using asynchronous queue delivery and automatic deduplication. Leads now appear in the pipeline within 5 seconds, and leftover tasks are automatically assigned to the next available agent. Result: 30% increase in conversion and $12,000 saved annually in administrative overhead.

Timelines

Scenario Duration
One CRM, lead transfer from forms 1‑2 weeks
Two‑way synchronization + statuses 3‑5 weeks
Multiple CRM + custom field mapping 4‑8 weeks

The exact cost is calculated after an audit of your current processes and CRM data structure. Contact us for a project estimate – we will send a commercial proposal within one business day. With 5+ years of experience and more than 20 completed integrations, you get a solution that works from day one. Get an engineer consultation to see how your sales funnel can run without manual lead transfer.

Additional sources: Customer relationship management (Wikipedia) · REST API (Wikipedia)