---
title: "Full-Stack Embedded Signing Guide for ASP.NET Core"
description: "Implement full‑stack embedded signing with BoldSign. Keep signers in‑app, automate document workflows, and ensure compliance with secure, scalable APIs."
url: "https://boldsign.com/blogs/full-stack-embedded-signing-implementation-guide/"
---

1. [Blog](https://boldsign.com/blogs.md)
2. [API](https://boldsign.com/category/api.md)

# Full‑Stack Embedded Signing Using BoldSign

[Evans Omondi Otieno](https://boldsign.com/author/evans-omondi-otieno/) May 25, 2026 Updated August 17, 2026 9 min read

> **TL;DR**: A full-stack embedded signing setup allows you to integrate document signing directly into your application with no external redirects. Your backend creates the signing request and generates a secure signing link, while your frontend loads the signing experience inside the app.

Imagine a user logs into your application to complete an important task such as onboarding, signing a contract, or finalizing an agreement.

Everything works smoothly until the final step, where the experience often breaks down.

The user receives an email, clicks a link, gets redirected to another platform, signs the document, and then tries to return to your app.

This context switching causes confusion, delays, and often leads to user drop-offs.

## A better approach

Now, imagine a better experience.

The user clicks “Sign Document,” and the signing interface loads instantly within your application. There are no redirects, no email dependencies, and no interruptions.

This approach reduces drop-offs, improves completion speed, and creates a consistent user experience.

This is what embedded signing with BoldSign enables.

## What you will build in this guide

In this guide, you will build a real-world ASP.NET Core MVC implementation that:

- Sends a document for signing using BoldSign
- Disables email notifications to keep the experience fully in-app
- Generates a secure embedded signing link server-side
- Displays the signing experience directly within your app using an iframe
- Verifies Webhook events with HMAC-SHA256 and handles document completion

By the end of this guide, you will have a working reference implementation of an in-app signing flow.

## What are the prerequisites for this implementation?

Before you start, make sure you have the following in place:

- A [BoldSign account](https://account.boldsign.com/signup?planId=1076) with API access enabled.
- A [BoldSign API key](https://developers.boldsign.com/authentication/api-key/) from your developer settings. Keep it in server-side configuration only.
- .NET 6 or later installed on your development machine.
- An ASP.NET Core MVC project (this guide creates one from scratch).
- The [BoldSign .NET SDK](https://developers.boldsign.com/sdks/net-sdk/)
- A publicly reachable Webhook URL is required. For local development, use [ngrok](https://ngrok.com/) or a similar tunnel to expose your local server to the internet.

If you are testing locally, run ‘ngrok http 5000’ and use the generated HTTPS URL as your Webhook endpoint in BoldSign dashboard [Webhooks settings](https://developers.boldsign.com/webhooks/setting-webhook/?region=us).

## A real-world scenario: RentEase property management

To make this concrete, we will use a property management platform called RentEase.

A property manager uploads a lease agreement. A tenant logs in to review and sign it. The goal is to keep everything inside the platform: simple, seamless, and secure. Instead of sending a tenant outside the app via email, the entire signing experience is embedded within it.

This same pattern applies to HR onboarding, loan applications, SaaS subscription agreements, and healthcare consent forms.

## How does the embedded signing flow work end‑to‑end?

Here is how everything connects behind the scenes:

1. Property manager uploads lease and enters tenant details
2. Backend sends the document to BoldSign with `DisableEmails = true`       
3. BoldSign returns a unique `DocumentId` 
4. Backend generates a secure embedded signing link
5. Frontend loads the signing experience inside an iframe
6. Tenant signs the document directly within the application
7. BoldSign Webhook fires the Completed event
8. Backend updates status and redirects to confirmation

From the user’s perspective, the experience is smooth and connected with no context switching.

## Getting started

Create a new ASP.NET Core MVC project:

```
dotnet new mvc -n RentEase
cd RentEase
dotnet add package BoldSign.Api
```

Configure your BoldSign API key in appsettings.json:

```
{
  "BoldSign": {
    "ApiKey": "YOUR_BOLDSIGN_API_KEY",
    "BaseUrl": "https://api.boldsign.com"
  }
}
```

Set the API key in your service configuration:

```
var apiClient = new ApiClient(
    Configuration["BoldSign:BaseUrl"],
    Configuration["BoldSign:ApiKey"]
);
```

### Step 1: Sending the document from your backend

When the property manager uploads a lease, your backend prepares and sends it to the BoldSign API. The most important setting here is `DisableEmails = true`. This ensures BoldSign does not send email links to the signer, keeping the entire experience inside your application.

```
var documentClient = new DocumentClient(apiClient);

List<FormField>  formField = new List<FormField>
{
    new FormField(
        id: "Signature",
        type: FieldType.Signature,
        pageNumber: 1,
        bounds: new Rectangle(x: 50, y: 50, width: 200, height: 30))
};

var documentDetails = new SendForSign
{
    Title = "Lease Agreement - RentEase",
    DisableEmails = true,
    Signers = new List<DocumentSigner>
    {
        new DocumentSigner(
            signerName: "Tenant Name",
            signerType: SignerType.Signer,
            signerEmail: "tenant@example.com",
            formFields: formField)
    },
    Files = new List<IDocumentFile>
    {
        new DocumentFilePath
        {
            ContentType = "application/pdf",
            FilePath = "lease.pdf"
        }
    }
};

var documentCreated = documentClient.SendDocument(documentDetails);
var documentId = documentCreated.DocumentId;
```

Store the document ID in your database immediately. Every subsequent operation, including Webhook routing, depends on it.

#### Why must emails be disabled?

If you do not disable email notifications, BoldSign sends a separate signing link via email. A tenant may open that link instead of the in-app iframe, bypassing your application entirely and breaking the experience you built. Setting `DisableEmails = true` ensures a controlled, uninterrupted embedded signing flow.

### Step 2: Generating the embedded signing link

Generate the signing link on the server side when the tenant is ready to sign. Do this at display time, not at document send time, because the document may still be processing immediately after sending.

```
var documentClient = new DocumentClient(apiClient);

var embeddedSigningLink = documentClient.GetEmbeddedSignLink(
    documentId: "YOUR_DOCUMENT_ID",
    signerEmail: "tenant@example.com"
);

var signLink = embeddedSigningLink.SignLink;
// Return signLink to the frontend, never the API key
```

The `signLink` is a short-lived URL tied to a specific signer and document. Never expose your BoldSign API key in frontend code. Generate the link in your controller or service layer and pass only the URL string to the view.

### Step 3: Rendering the signing experience in an iframe

```
<iframe
    src="@Model.SignLink"
    width="100%"
    height="100%"
    style="border: none; min-height: 700px;"
    title="Sign your lease agreement">
</iframe>
```

```
// Controller action that returns the signing view
public IActionResult SignDocument(string documentId)
{
    var tenantEmail =
        User.FindFirst(System.Security.Claims.ClaimTypes.Email)?.Value;

    // Verify this document belongs to the authenticated tenant
    var record = _documentService.GetDocument(documentId, tenantEmail);
    if (record == null) return NotFound();
    var signLink = _documentService.GetSignLink(documentId, tenantEmail);

    return View(new SignDocumentViewModel
    {
        DocumentId = documentId,
        SignLink = signLink
    });
}
```

Once your backend returns the `signLink`, embed it in an iframe in your **Razor** view:

This keeps the tenant inside your application from start to finish.

### Step 4: Handling Webhook events

After a tenant signs, BoldSign sends an HTTP POST to your Webhook endpoint. You must verify the HMAC-SHA256 signature on every event before processing it.

#### What events matter?

Here are some of the document events in the flow:

| | | |
| - | - | - |
| **Event** | **When it fires** | **What to do** |
| Signed | Each signer completes their action | Update signer status accordingly |
| Completed | All signers finished, final PDF ready | Update document status, download signed document, notify property manager |
| Declined | A signer declined to sign | Alert property manager |

Use **Completed** as the trigger for all final actions: downloading the signed PDF, unlocking the next workflow step, and sending confirmation.

## How do you verify the Webhook signature?

BoldSign signs every Webhook with HMAC-SHA256. The signature header looks like:

```
x-boldsign-signature: t=1668693823, s0=9b7adf82fbd470cce0cdb8106d7cb023e547999ada5e8c9ad02306cd22ee7ca9
```

The signed payload is `{timestamp}.{raw_body}`. Use constant-time comparison to verify the signature.

To prevent replay attacks, validate the timestamp included in the signature and reject events that fall outside an acceptable time window (commonly around 5 minutes).

## Webhook handler example

```
[HttpPost("webhooks/boldsign")]
public async Task <IActionResult> BoldSignWebhook()
{
    using var reader = new StreamReader(Request.Body);
    var json = await reader.ReadToEndAsync();

    // Respond to BoldSign's verification ping immediately
    if (Request.Headers["X-BoldSign-Event"] == "Verification")
        return Ok();

    var signature = Request.Headers["X-BoldSign-Signature"].ToString();
    var secretKey = _configuration["BoldSign:WebhookSecret"];

    // Verify HMAC before any processing
    if (!WebhookUtility.ValidateSignature(json, signature, secretKey))
        return Forbid();

    // Acknowledge immediately — process async
    var evt =JsonSerializer.Deserialize<BoldSignEvent>(json);

    _ = Task.Run(() => ProcessEvent(evt));

    return Ok();
}

void ProcessEvent(BoldSignEvent evt)
{
    if (evt.Event.EventType == "Completed")
    {
        var documentId = evt.Data.DocumentId;
        var messageTitle = evt.Data.MessageTitle;

        var document = _documentService.MarkCompleted(documentId);

        var documentClient = new DocumentClient(apiClient);

        // Download final signed document
        using (var stream = documentClient.DownloadDocument(documentId))
        {
            Directory.CreateDirectory("SignedDocuments");

            // Add your document title here
            var documentTitle = "Your Document Title";

            var filePath = Path.Combine("SignedDocuments", $"{documentTitle}.pdf");

            using (var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
            {
                stream.CopyTo(fileStream);
            }
        }

        _notificationService.NotifyManager(document.TenantId, document);
    }
}
```

> Note: For production systems, consider using a background worker or queue instead of Task.Run for better reliability.

Always return HTTP 200 to BoldSign immediately, then process asynchronously. If you process synchronously before returning, BoldSign may time out and retry the Webhook, causing duplicate events.

## Raw body configuration

In ASP.NET Core, the Webhook endpoint must access the raw request body exactly as received for HMAC signature verification. Any modification (such as JSON parsing or reformatting) will invalidate the signature.

Because the request body stream can only be read once by default, enable request buffering (e.g., EnableBuffering()) or use middleware to capture and reuse the raw body safely during verification.

## What security best practices should you follow?

Security best practices for your project:

1. Generate signing links only on the server. Never call BoldSign from frontend code.
2. Verify the logged-in user matches the signer. Check that the authenticated tenant owns the document before generating a sign link.
3. Never expose API keys in frontend code. Use server-side calls only.
4. Always use HTTPS. BoldSign requires TLS for all API and Webhook traffic.
5. Use constant-time HMAC comparison. This prevents timing attacks on Webhook verification.
6. Set a reasonable sign link expiry. Generate signing links just-in-time rather than far in advance, as embedded signing URLs are short-lived.
7. Track processed Webhook event IDs. BoldSign retries failed deliveries. Deduplicate by storing event IDs to avoid double-processing.

BoldSign manages encryption, compliance, and audit logging. Your application controls access, identity verification, and user experience.

## What real‑world use cases fit embedded signing best?

Here are some of the real-world use cases for embedded signing:

**Employee onboarding (HR & internal systems)**

In employee onboarding workflows, embedded signing allows new hires to review and sign employment contracts, NDAs, and policy acknowledgements directly within the company’s HR portal. Instead of receiving multiple emails or being redirected to an external signing page, employees complete all required documentation in one guided flow.

**Loan applications and financial services**

For banks and fintech platforms, embedded signing enables customers to complete loan agreements, disclosures, and consent forms without leaving the application. Once a user finishes their loan application, the signing experience loads instantly within the same interface, allowing the customer to sign and proceed to confirmation or disbursement steps seamlessly.

**SaaS subscription and upgrade agreements**

SaaS platforms often require users to accept subscription terms, data processing agreements, or enterprise contracts when upgrading plans. Embedded signing makes this part of the in‑app upgrade or checkout flow, allowing agreements to be reviewed and signed without redirecting users to email links or third‑party pages.

**Healthcare consent and registration forms**

Healthcare providers and digital health platforms use embedded signing to collect patient consent forms, privacy acknowledgements, and insurance authorizations within patient portals. Patients can complete all required documentation before appointments, reducing administrative delays and paperwork at check‑in.

**Education and e‑learning platforms**

Educational institutions and e‑learning platforms use embedded signing during student enrollment to collect signed agreements, codes of conduct, and consent forms. Students complete these steps directly within the learning platform, and access to courses or resources can be automatically enabled once signing is complete.

**Insurance policy issuance**

In insurance workflows, embedded signing allows customers to sign policy agreements and disclosures as part of the purchase journey. Instead of waiting for email‑based signing, policies can be reviewed and signed instantly within the insurer’s application, enabling immediate policy activation.

## Final thoughts: Embedded signing implementation

Embedded signing is more than just an integration; it’s a better way to design your user experience. Instead of sending users elsewhere to sign documents, you bring signing directly into your application.

Ready to embed signing workflows into your app? [Sign up for BoldSign](https://account.boldsign.com/signup?planId=1076\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign) today and transform how your users sign documents.

For more details, refer to the BoldSign [API documentation](https://developers.boldsign.com/api-overview/getting-started/).\
Need assistance? Contact [our support team](https://support.boldsign.com/) via the support portal or schedule a [personalized demo](https://boldsign.com/request-demo.md).

Topics [Embedded signing](https://boldsign.com/blogs/tag/embedded-signing.md)[API integration](https://boldsign.com/blogs/tag/api-integration.md)[Webhooks](https://boldsign.com/blogs/tag/webhooks.md)

## Sign documents 3x faster

Send, sign and manage documents securely and efficiently.

[Try it today](https://account.boldsign.com/signup?planId=1018\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign)

## Frequently asked questions

### How do I get the embedded signing URL?

Call GetEmbeddedSignLink with your documentId and signerEmail. The response contains a `signLink` field with the time-scoped URL to embed in an iframe. Generate this link server-side only.

### How do I authenticate API requests?

Authenticate using your BoldSign [API key](https://developers.boldsign.com/authentication/api-key/) set in your server-side configuration, or via [OAuth 2.0](https://developers.boldsign.com/authentication/oauth-2-0/) for higher-security integrations. Never expose credentials in frontend code.

### How is security handled in embedded signing?

Layered controls protect every step: documents are encrypted, access uses short-lived signer-specific URLs, APIs are authenticated with [API keys](https://developers.boldsign.com/authentication/api-key/) or [OAuth 2.0](https://developers.boldsign.com/authentication/oauth-2-0/), and [Webhook payloads](https://developers.boldsign.com/webhooks/verify-webhook-events/) are HMAC-signed. Your application enforces user identity and access control.

### Do signers need a BoldSign account?

No. Signers do not need to create or log in to a BoldSign account. The embedded URL authenticates the signing session. Your application handles user identity verification.

### How do I know when a document is signed?

Use [Webhooks](https://developers.boldsign.com/webhooks/webhook-configuration-and-lifecycle/). Subscribe to `Signed` for per-signer completion events and `Completed` for the final event when all signers have finished and the PDF is ready. Webhooks notify your application automatically, no polling required.

### Can I customize the embedded signing UI?

Yes. You can apply your own [branding](https://developers.boldsign.com/branding/create-brand/), logos, and colors to match your application. This is configured in your BoldSign account settings or via parameters passed when generating the sign link.

### What happens if my Webhook endpoint is down?

BoldSign [retries Webhook delivery](https://developers.boldsign.com/webhooks/webhook-configuration-and-lifecycle/) for failed requests. Make your handler idempotent by tracking processed event IDs. If you receive the same event ID twice, discard the duplicate.

## Evans Omondi Otieno

Evans Omondi Otieno is a customer support representative and writer at BoldSign, specializing in creating clear, insightful content to help users navigate eSignature solutions. As a blog author, Evans writes well-researched articles that simplify technical concepts, helping businesses and professionals understand how to use BoldSign effectively. With expertise in technical support and content creation, he ensures users have a seamless experience and gain valuable knowledge from his articles.

[More posts by Evans Omondi Otieno](https://boldsign.com/author/evans-omondi-otieno/)

## Related posts

- [API](https://boldsign.com/category/api.md) May 18, 2026 6 min read

  ## [Best eSignature API for SaaS: What Developers Should Evaluate](https://boldsign.com/blogs/best-esignature-api-for-saas-developer-guide.md)

  Compare eSignature APIs on 12 developer criteria: REST design, SDKs, embedded signing, webhooks, rate limits, and pay-as-you-go pricing from $0.75 an envelope.

- [API](https://boldsign.com/category/api.md) September 22, 2026 9 min read

  ## [What Are the Common Challenges When Using Signature APIs in Software Development](https://boldsign.com/blogs/common-signature-api-challenges.md)

  Explore the common challenges developers face with a Signature API, from authentication issues to PDF rendering, webhooks, templates, and rate limits.

- [API](https://boldsign.com/category/api.md) July 2, 2026 11 min read

  ## [How Embedded Lease Signing Speeds Real Estate Lease Workflows](https://boldsign.com/blogs/embedded-lease-signing-real-estate-apps.md)

  See how embedded lease signing helps real estate apps generate leases, prefill data, collect eSignatures, track status, and complete agreements faster

Get started

## Sign up for your free trial today!

[Start free trial](https://account.boldsign.com/signup?planId=1018)

- 30-day free trial
- No credit card required

*Picture: A completed employment contract: signed by John Doe on 11/03/2026, all parties have signed*
