Skip to end of metadata
Go to start of metadata

NemID is a collaboration between the Danish banks and the Danish public sector. This alliance forms a countrywide solution and is set to be the new, secure login mechanism for internet sites wanting to utilize the free of charge digital ID for all citizens in Denmark. At January 2011 a total of 3 mill. Danish citizens had ordered a NemID.

Late 2011 it is expected that DanID will launch NemID Employee signature. This will ensure a unified platform for both citizens and enterprises in Denmark. Signicat will continue to support the two older Danish ID solutions, Net-ID and Digital Signature (OCES) for as long as these remains active.


Merchant certificate

A merchant certificate (signature) represents your business, and is used by the web application to communicate securely on your behalf. Merchant certificates for NemID are called VOCES ("Virksomheds OCES" or "Virksomhedssignatur"). There are different merchant certificates for the preproduction and production environment.

Merchant certificates for the preproduction environment are free while there is a fee for production merchant certificate.

This page (external link) contains an order form for ordering a NemID merchant certificate.

Employee certificate

An employee signature is a personal certificate, but it is associated with your company. With an employee signature you may sign on behalf of your company.

This page (external link) contains an order form for ordering a NemID employee certificate.

Personal certificate

NemID is the new Danish eID solution for use on both public and private services on the web.

End users may order their personal digital signature on this page (external link).


This process description shows the interaction between the Customer, DanID and Signicat Operations when developing and establishing a Web application using Danish NemID. The process contains descriptions of all the players tasks.

Signicat will be happy to assist you in ordering and setting up Danish NemID.

The documentation from DanID refereed to in this process description is mainly in Danish. However a complete documentation-package in English on NemID, is available from this page (external link).

Read this page on DanID's website on how to become a NemID merchant (external link).

Process overview

  1. Customer signs agreement with Signicat AS
  2. Customer signs agreements with DanID
  3. Customer develops technical integration with Id.signicat
  4. Customer orders VOCES and access to test environment
  5. DanID establishes service provider in test environment
  6. Signicat configures customer integration in test environment
  7. Customer performs acceptance test in test environment
  8. Customer orders VOCES and access to production environment
  9. Signicat configures customer integration in production environment
  10. Customer performs the acceptance test in production environment

1. Customer signs agreement with Signicat AS

The Customer signs an agreement with Signicat AS. This agreement specifies:

  • the Service Level (SLA) between the Customer and Signicat AS
  • the number of ID-methods (authentication, signing, verification, etc)
  • the number of ID-solutions (NemID, Net-ID, BankID, etc)
  • the number of graphical profiles the Customer needs
  • etc

2. Customer signs agreements with DanID

The Customer signs the following agreements agreements with DanID:

  • A NemID service provider agreement.
  • If the Customer needs to receive CPR numbers (social security numbers) of the end-users, an agreement to use the PID/CPR-service must also be signed. There are two different modes of PID-CPR access:
    • Match: This mode requires the end-user to type his or hers CPR-number in your web-application, and also requires the users explicit consent. The CPR-number and PID-number (retrieved from the users NemID login) is transmitted to, and matched in the PID/CPR-service. A simple true/false is returned to the web-application.
    • Lookup: From the end-users NemID login the PID-number is retrieved and transmitted to the PID/CPR-service. The PID/CPR-service is returning the corresponding CPR-number to the web-application. The user is not involved in the retrieval in any way.
      NB! This option is only available for public enterprises and authorities.

Select this page to get detailed information about the agreements, and to download and fill in the agreement forms.

3. Customer develops technical integration with Id.signicat

NB! This step only applies to new customers of Signicat or existing customers without integration to Id.signicat.

When the relevant agreements with Signicat and DanID are signed, the Customer should begin developing a standard technical integration with Id.signicat. This includes:

  • A technical development with one of the Signicat client kits
  • Establishing one or more graphical profiles
  • Testing the integration

4. Customer orders access to test environment and VOCES

4.1 Customer orders access to DanID test environment

Important tasks in this step:

  • Get permission to access DanIDs test environment for NemID. Fill out the order form on this page (external link).
  • If the Customer wants DanID to provide a VOCES test certificate to access the test system, be sure to select this option in the order form.
  • The Customer receives a confirmation email from DanID containing
    • a link for obtaining a VOCES test certificate for the test environment,
    • link to a form (TestTool) for ordering test users.

4.2 Customer orders test users

This step is performed after 4.1. Important tasks in this step:

  • For each test user, the Customer must enter a series of informations (e.g. CPR number, name, address etc.) in the order form. Please refer to the documentation “Vejledning I brug af test tools” (Guidelines on the use of test tools) on this page (external link) on how to use the TestTool.

5. DanID establishes service provider in test environment

This step takes place normally 14 days after 4.2. Important tasks in this step:

  • DanID establishes a service provider configuration for the Customers in their test environment.
  • DanID sends an email with an activation link for the VOCES certificate to the technical responsible (according to Customer's contract with DanID).
  • DanID sends an email containing the test users with OTP codes to the the technical responsible.

6. Signicat configures customer integration in test environment

Important tasks in this step:

  • Signicat receives the email containing the activation link for the VOCES certificate from DanID or the Customer (according to Customer's contract with DanID). If the Customer is the recipient of the e-mail, then it must be forwarded to Signicat.
  • Signicat downloads and activates the VOCES certificate for test, using the activation link.
  • Signicat establishes a NemID configuration for the Customers integration in Signicat's test environment.

7. Customer performs acceptance test in test environment

The test should cover all aspects of the Customer NemID integration in Signicats test environment, i.e.:

  • Authentication/signature with valid test certificates
  • Authentication/signature with revoked test certificates
  • Authentication/signature with locked test certificates

A extensive guide on testing your NemID integration can be found on this page (external link).

8. Customer orders VOCES and access to production environment

8.1 Customer orders VOCES for production

NB! This step only applies for Customers that don't have VOCES certificate for production.

Important tasks in this step:

  1. The Customer or Signicat orders a VOCES certificate for production environment. This is done by filling out the order form on this page (external link).
  2. The technical responsible person eceives an email with the activation link to the VOCES certificate. A letter containing a PIN code which is required for activating the VOCES certificate will also be sent from DanID.
  3. The technical responsible (if he/she is not a person on Signicat) must forward the email to The PIN code (from the letter) must also be sent to Signicat, via SMS or mail.

8.2 Customer orders access to DanID production environment

This step requires that the Customer has a VOCES certificate for production.

  • The Customer sends a request to DanID to get permission to the NemID's production environment. This is done by filling out the order form on this page (external link).
  • When the production date approaches (according to Customer's contract with DanID), access to the production environment will be opened.

9. Signicat configures the Customer's integration in production environment

Important tasks in this step:

  • Signicat receives the email containing the activation link and the activation PIN code for the VOCES certificate for production, from DanID or the Customer (according to Customer's contract with DanID)
  • Signicat downloads and activates the VOCES certificate for production, using the activation link and PIN code.
  • Signicat establishes the Customer configuration for the NemID integration in Signicat's production environment, and installs the VOCES certificate.

10. Customer performs the acceptance test in production environment

The test should cover all aspects of the NemID integration for the Customer in Signicats production environment.

 Test information




Whether you already have signed a service provider agreement with DanID, or just considering becoming NemID service provider, DanID need some information about your company in order to give you access to NemID test environment.

It is a prerequisite for accessing NemID test environment that you have a test company signature (test VOCES), since a production company signature can not be used in the test environment. If you already have a test-Corporate Signature, you can use it, alternatively you may order one at DanID.

Friendly Name

The Friendly Name field will be displayed in NemID applet to identify the service provider that the user tries to access. The user would for example be able to read, "You are now by logging on Acme Corp" where Acme Corp in this case constitutes Friendly name. Note: DanID make a concrete assessment of whether Friendly name is correct.

CVR/UID from the test VOCES certificate to test system

Information about CVR/UID in the test VOCES certificate may be found in the certificate details. It contains the field "Subject", under properties, serial number (serialNumber) and the value for CVR/UID can be read here.

Service provider package

Once agreements are signed, you must fill out a form for establishing service provider so that you receive access to the right systems in DanID. You can find this form together with your service provider package, which also provides information and software for use in the testing phase.

Read more about establishing agreement and service provider package.

Creating test users

DanID have developed a tool that enables service providers themselves to create the test users they want. With this tool you can:

  • Create a new test user with key card and temporary password
  • See transaction logs for a specific test user
  • The tool automatically ensures that new key cards are granted when there are only 20 keys left on the key card

For more information about the creation of test users, click the "Creating test users" tab at the top of this page.

Recommended test procedures (in Danish) contains DanID's recommended test procedures.

Error codes

nemid errorcodes.xlsx contains an overview of the error codes from NemID.

Browser/platform support

For complete list of supported browsers, please visit this page on (NB! In Danish language.).

1. Gain access to DanID's developer environment -

To obtain test-users, it's a requirement that your company's IP addresse(s) are whitelisted by Nets/DanID.

Access require an provider agreement (tjenesteudbyderaftale) with Nets/DanID. If you don't have this, you may apply and fill in your IP's here: (Danish).

If you have an existing provider agreement (tjenesteudbyderaftale) with Nets/DanID and you can't access the page mentioned above, please contact TU-support to have your IP's added (max 10 per company).

2. Create a NemID test user

Go to 

  • Click "Autofill" to fill all fields with valid test data
  • Change alias (username) and password to whatever you'd like
  • Click "Create new identity" and wait


3. Get an overview of the user

After clicking Submit, you’re redirected to the overview page — this page should be bookmarked. From here you can issue new OTP cards and find other, useful data about your test user. The username (alias) you created will allow you to look up this page again. The CPR number here will be important for authentication with CPR/PID checks, so make sure you save it.

4. Save the link to the OTP card

Now click the OTP card link — this will send you to this users' OTP card page. You'll want to bookmark this for future use, as the codes here are necessary for NemID authentications.

5. Congratulations

Congratulations, the registration process is now complete! You may now use your new NemID for NemID authentication. Again — please remember to save your password, user ID, CPR number and OTP card link. Signicat will not be able to help you recover any data or user, so store the information safely. To reiterate, this is the order in which you will need your test user information when authenticating with NemID:

  • Fill in username and password
  • Refer to your OTP card link to find the serial which corresponds with the number presented in the NemID window
  • Fill in your CPR number if/when prompted





 Production environment

In order to go into production with NemID, your company will need the following:

  • A service provider agreement with DanID
  • An agreement to use the PID-CPR service (optional, but necessary if you need to receive CPR-numbers from the users).
  • Agreement to use their production environment.
  • A VOCES merchant certificate for production.

VOCES merchant certificate for production

Click this link to access the VOCES order form.

You need to specify:

  • CPR-number of the merchant
  • Name/friendly name of the application (service name, department name, etc)
  • Technical contact person (name and email address)
  • Granted person (name and email address)
  • Email address associated with the VOCES certificate (merchant, department, etc email address )
  • Comments
 Typical login and signature screenshots

This page contains screenshots of a typical login session and signature session. The actual screens may have a different graphical profile in your setup.

The graphical interface in Signicat's NemID product consists of the standard NemID applet as it is delivered from DanID, plus a "CPR step" that Signicat has developed. The standard NemID steps are shown in paragraphs 1-3 on this page, while the CPR-step is described in paragraph 4.

Login session

The pictures below illustrates the login/authentication process with NemID.

1. Provide user-id and secret code

The user provides his/her user-id and secret code. The user-id may be the users CPR-number, a unique NemID number, or a username chosen by the user him-/herself. Such a username may be created on the first use of NemID.

2. Provide one-time key

The user provides a one-time code from his/hers code card.

3. Process users input data

NemID processes the input data from the user.

4. Provide CPR-number

The standard NemID applet returns only a number called PID to the merchant, and not the CPR-number, which is needed in most cases. The PID is a number that identifies the end user uniquely, and is internal and specific to the NemID systems.

In order to retrieve the users CPR-number, DanID's PID-to-CPR-service must be used. The PID-to-CPR-service has two different modes: lookup and match:

  • Lookup mode, the CPR-number will be extracted by the service using the PID as key (requires no user interaction).
  • Match mode, the end user has to enter his/hers CPR-number. The number entered by the user will be matched against the CPR-number that is extracted by the PID-to-CPR-service. If the CPR-numbers are equal, the user can continue.

Danish legislation has determined that only public merchants are allowed to use the PID-to-CPR service in lookup mode. Private merchants has to use the PID-to-CPR service in match mode.

Signicat's graphical interface to the PID-to-CPR service is shown in the picture below.

It enables the user to enter the CPR-number, then match it against the PID-to-CPR service. This step is invisible if PID-to-CPR service is configured to run in lookup mode.

Ultimately, the user is allowed to store the CPR-number in Signicat's system. If the user chooses to store the CPR, he/she will avoid this step in the future.

Signicat store the CPR numbers as long as the user is active, but if the user stops using the service for a while, the CPR number will be deleted after a certain time. A batch job runs every night and deletes all CPR-numbers that have been unused for 3 months or more. The limit of 3 months is consistent with the Norwegian legislation.

Signature session

The process below illustrates a very basic process of how to sign a PDF-document with NemID. With Id.Signicat, the graphical design can be customized so that the signature process appears to be a part of the merchants web application. The process contains following steps:

  1. Select the PDF-document that should be signed. This depends on how the application is designed.
  2. Open and read the PDF-document, select "Fortsæt" (Continue).
  3. Confirm that you have read and understood the contents of the document, using your NemID userid and password.
  4. Confirm the signature with the requested one-time code from your code card.
  5. Provide your CPR-number

The PDF-document is now signed.

Step 1: Select PDF-document

Step 2: Open and read the PDF-document

Step 3: Confirm that you have read the document

Step 4: Enter the requested OTP code

Step 5: Provide your CPR-number

 Getting started with authentication

SAML 1.1 & SAML 2.0


Signicat offers authentication services using either SAML 1.1 or SAML 2.0. If you are using an identity federation service such as Microsoft ADFS or Oracle Identity Federation, then you are most likely interested in Signicat SAML2 gateway.

See the documentation for Signicat's SAML 2.0 interface if that is the case.


Authentication using SAML 1.1


Commonly, the authentication process starts in your application and will consist of the following steps. You are required to carry out the actions marked in bold.

  1. Redirecting the user to Signicat: You are the service provider (SP) and you need to authenticate an end user in order to grant him or her access to some service. In order to do that, you redirect the user to Signicat (in the browser).
  2. Signicat will host the entire authentication process using any of the available (or desired) id methods, after which a SAML assertion (XML) is constructed. The SAML assertion will be signed with a certificate which ensures that the contents of the assertion cannot be spoofed or altered.
  3. Receiving the SAML response: Signicat will then redirect the user back to your application along with the aforementioned SAML assertion.
  4. Verifying the SAML response: Your application will pick up the SAML assertion and validate it to make sure it's correct.
  5. Retrieving attributes from the SAML response: After validation has taken place, the values in the SAML assertion (such as user name, personal identity number etc.) can be extracted and processed by your application for further usage (typically logging the user in).

Redirecting the user to Signicat

The first step of the authentication process is as easy as constructing a URL. The URL will have the following format:

where the red parts will depend on what you want to do:

  • env is the environment. When you're first starting out, this will typically be preprod, and in production it will be id.
  • service is the name of your service as registered with Signicat*. There is a demo preprod service called demo which you may use as you'd like, but eventually you will start using your own service.
  • method is the name of the id-method as registered with Signicat*. Common abbreviations are nbid for Norwegian BankID, sbid for Swedish BankID, nemid for Danish NemID, tupas for Finnish Tupas, esteid for Estonian ID-card and so on.
  • profile is the name of the graphical profile** you would like to use. If you don't have a graphical profile, you can omit the value and the default profile will be used.
  • language is the (ISO 639-1) two letter code for the language you would like in the user interface, such as nb for Norwegian, da for Danish, sv for Swedish, fi for Finnish, et for Estonian and so on.
  • target is the URL-encoded (or "percent encoded") URL to the application which is to receive the SAML assertion. If you're starting out testing the services, then perhaps your URL is http://localhost:8080/auth/verify and if you URL encode that you'll end up with http%3A%2F%2Flocalhost%3A8080%2Fauth%2Fverify. Any parameters you use in any of your URL's should always be URL encoded according to the URL standard, so make sure you adhere to that.

Note that all URL parameters must be properly URL encoded using UTF-8, as per RFC 3986.

* If your company name is Foo then your service name can be "foo", and if you're using Danish NemID then the method name can be "nemid" or something completely different if you'd like. Please contact if you're unsure of the name of your service and/or available id-methods.

** A graphical profile is an HTML template which can be used to wrap the dynamic content served by Signicat. See also How to work with graphical profiles.


Let's put the pieces together and construct a URL where we send the user to the preprod environment, using the demo service, the Danish NemID method, a demo profile, danish language and localhost as the target:

Clicking the link will send you to a page where the NemID applet is loaded and the authentication process starts, such as in the following screenshot:

Receiving the SAML response

After authenticating, Signicat will redirect the user to the target using HTTP POST. In terms of HTTP, this is what the request would like like:

SAML 1.1 POST profile


Host: localhost:8080
Proxy-Connection: keep-alive
Content-Length: 9213
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip,deflate,sdch
Accept-Language: en-US,en;q=0.8
SAMLResponse=PFJlc3BvbnNlIHhtbG5zPSJ1c...and so on and so on...Rpb24%2BPC9SZXNwb25zZT4%3D%0D%0A&TARGET=http%3A%2F%2Flocalhost%3A8080%2Fvalidate


Decoding the SAML response will result in the actual SAML (XML) document which contains information about the authentication. Read more about SAML or have a look at example SAML responses for different id providers.


Verifying the SAML response

The SAML response is a signed XML (xml-dsig) and the signature must be verified in order to ensure the correctness of the assertion. Signicat provides libraries that will help you verifying the SAML using Java or C#.

  1. How to verify a SAML response using Java
  2. How to verify a SAML response using C#
  3. Links to the certificate if you use your own integration: SAML certificate

Retrieving attributes from the SAML response

Please refer to this overview of which attributes are available in the SAML responses.

 Getting started with signatures

Signicat Sign offer flexible solutions for electronic signatures and seals. The digital communication as well as exchanging of digital documents is increasing and the need of security likewise. Signicat Signature and Signicat Seal ensures document origin, integrity and non-repudiation.

Signicat Sign is a collection of advanced web services enabling companies to utilize electronic signatures in business processes. The services are hosted in a secure environment with redundancy and dynamic capacity. Recurring security assessments are performed and the services are audited by KPMG.

Signicat Sign supports the use of any type of electronic identity method provided with our authentication product, Signicat Connect, for applying the signature. This ensures a unified output format in accordance with EU specifications, and ensures a scalable, responsive signflow which supports almost any modern device standards and window sizes available for consumers today.

Getting started with Signicat Signature

The following is an introductory guide to understanding and getting started with Signicat Signature, the signature services we provide to our customers. For the sake of brevity, this document will link to a number of separate guides, examples and more exhaustive documentation when it is deemed necessary.

The commercial terms for using the services is based on a modular approach and this document does not consider pricing of the services, but only serves to provide a functional description of the services. Please contact your Signicat Account Manager for pricing details.

This guide has been sorted into the following sections — click each of them to expand:


 Overview of Signicat Signature

When you start out with Signicat Signature, you are allowed to choose freely from the options offered in the following categories:

  • Which signing method(s) to use
  • Which functionality you require
  • Customization options for UI and PAdES

We'll describe all three in detail below, as well as the Web Services allowing you to start implementing Signicat Signature:

Signing methods

Sign using Signicat Connect

Signicat Signature supports the use of any type of authentication method provided with Signicat Connect for applying the signature. Signing with Signicat Connect ensures a unified output format in accordance with EU specifications, and ensures a scalable, responsive signflow which supports almost any modern device standards and window sizes available for consumers today.

Signicat Connect allows you to choose from any of the following methods:

  • Norwegian BankID
  • Norwegian BankID Mobile
  • Norwegian Buypass
  • Norwegian Commfides
  • Danish NemID
  • Dutch iDIN
  • Finnish TUPAS
  • Finnish FINeID
  • Finnish Mobiilivarmenne
  • Swedish BankID
  • Swedish Telia
  • Estonian/Latvian EstEID
  • Estonian/Latvian EstEID Mobile
  • SMS
  • E-mail
  • Social media
  • YubiKey and YubiKey code
  • Mobile ID

Sign using third-party methods

In addition to Signicat Connect, we also support signing performed with third-party methods. These do not follow the same output formats, cannot be guaranteed to support responsive signflows and will not necessarily support all of the signing functionalities.

Third-party signing can be provided with the following methods:

  • Norwegian BankID
  • Norwegian Buypass
  • Norwegian Commfides
  • Swedish BankID
  • Swedish Telia
  • Danish NemID
  • Estonian EstEID
  • Estonian EstEDI Mobile
  • Spanish DNIe

Signing Functionality

The following functionality is supported, and may be utilized for signatures with Signicat Signature:

Input document formatsText and PDF.
Output document formats
XAdES and PAdES.
Multiple documents
The possibility to sign multiple documents. This also includes the option to sign all documents in a single operation.
Multiple signers
It is possible to add multiple signers who may sign in any order or in defined sequences.
Notifications can be sent to users using SMS or e-mail in asynchronous signing processes.
ViewerA web application for viewing and verifying signed XAdES documents.
Document uploadPerformed with our Session Data Storage as a part signing processes.
InkSignA chainable method for adding electronic, hand-written signatures to your documents.
FormsThe addition of simple data forms for adding additional user information.


We'll take a closer look at most of this functionality in the sections "Signature Requests step-by-step", "Signature Output" and "Features and Customization".

Customization options

Signicat Signature has a responsive UI — which means that the user interface will look nice and work normally across laptops, tablets and mobile phones. More information about customization options can be found in the section called Features and Customization further down in the document.

NOTE: When signing with a third-party method, the UI is partly defined by the provider and may or may not be responsive.

Web services

You will need to use Documentservice to integrate with Signicat Signature, with the other services below providing value-adding services to your document signature orders: 


DocumentService is a service with a SOAP web service interface. It is used for creating and manipulating document orders for document centric services at Signicat. The service may be used from any platform capable of making a SOAP web service call. Signicat provides several connector kits with wrapper classes for accessing the web service. A connector kit may or may not be used when calling the service.

For customers using Java we recommend using our Java connector, which you can find more information about here: Signicat Connector for Java

For customers using .NET we recommend using a web service reference directly to the web services located on For production usage, the same wsdl can be used, but changing the endpoint to or your subdomain will be neccessary. 

Reference documentation for DocumentService can be found here: DocumentService v3 - API

Signicat SessionDataStorage Service

Session Data Storage (SDS) is a temporary storage for documents with a REST interface. It is used in conjunction with Signicat's SOAP services where it is necessary to upload and download binary documents. SOAP interfaces are not particularly well suited to send large binary data. SDS's REST interface is, on the other hand, designed specifically to provide a fast and efficient protocol for uploading and downloading binary data.

SDS is designed to work in conjunction with other web services. In a typical use case, the client first uploads a document using SDS and then calls a method on SOAP web service with a reference to the newly uploaded document. The web service may respond with a message that references another document that the client may download from SDS.

Reference documentation for SDS can be found here: SDS (Session Data Storage)


PackagingService is a service with a SOAP web service interface used for packaging one or more third-party SDO's into richer SDO's of different types. It may be used to package one or more third-party SDO's into a PAdES SDO, for example. The service may be used from any platform capable of making a SOAP web service call, and relies on Signicat's SDS service or Signicats Archive Service (configurable in the soap request) for uploading and downloading binary document data.

Reference documentation for PackagingService can be found here: PackagingService v4 - API


The ArchiveService API can be used to access documents that are stored in Signicat's archive. All documents in the archive are identified with a unique archive reference which is must be used to access the document. Documents has no metadata and there is no functionality for searching for documents.

Reference documentation for ArchiveService can be found here ArchiveService v3 - API


 Signature requests step-by-step

In order to make a digital signature, a signature request needs to be created. A signature request defines the instructions for the signature engine — in its simplest form it specifies what is going to be signed and how it can be signed. 

The request is sent to the DocumentService web service, the URL for which can be found here (look for WSDL)DocumentService v3 - API

The typical lifecycle of a request is:

  1. Upload the documents to be signed to the Session Data Storage (SDS)
  2. Create a request with DocumentService
  3. Redirect the user to Signicat for the signing request
  4. Receive Status of the request
  5. Download the signed document from SDS

Due to the modular design of Signicat Signature, it is possible to deviate somewhat from this list — but for the moment we'll go through each of these steps in detail:

1 - Upload documents to be signed to the Session Data Storage

The SDS is a REST based interface where documents are stored temporarily. While it is possible to send the documents within the SOAP call made to DocumentService, it is generally recommended to use SDS for transfer of documents because SDS's REST based interface is more efficient and can deal with larger file sizes.

Instructions for using SDS can be found here: SDS (Session Data Storage)

2 - Create a request with DocumentService

A SOAP request needs to be made to DocumentService to specify the instructions for the request. Put simply, this is where you describe what to be signed, who needs to sign it and how they should sign.

Requests are made up of five main components:

  • Task(s)
  • DocumentAction(s)
  • Document(s)
  • Subject(s)
  • Notification(s)


More details about request creation can be found in the documentation: DocumentService v3 - API

3 - Redirect the user to Signicat for the signing request

When you want the user to start a signing action you will need to construct a URL leading the user back to signicat.

The URL will have the following format:

The red parts are as follows:

  • env is the environment. When you're first starting out, this will typically be preprod — in production it will be id. In production, if you have acquired a Signicat Subdomain, this must be be used instead.
  • service is the name of your service as registered with Signicat- There is a preproduction service called demo which you may use as you'd like, but eventually you will want to start using your own service.
  • request_id is the unique identifier for the requests that was created.
  • task_id is the unique identifier for a specific task in the request.
  • artifact, optional, and should only be included if the return value from DocumentService createRequest includes an artifact, or if you specify an artifact later using DocumentServive createArtifact. This is a short lived Single sign-on artifact, valid for only 30 seconds, and can be used to secure the signature order if you prefer not to require the end-user to login with a stronger ID (such as BankId) to be able view the documents before signing. Please see How to use artifacts to secure document orders for a complete code example. Please also see the section Features and customization for a more thorough description of artifacts and their usage.

NOTE: all URL parameters must be properly URL encoded using UTF-8, as per RFC 3986.

Example of a valid signing url:

For a code example of a simple request using C#, see the following: How to create a simple document order with one subject and one document using Danish NemID 

Request workflow and task order

The order in which the tasks of signature request is completed can be arranged by using "depends-on-task" within the Task datatype, allowing for complex workflows. For example: two customers and a salesman need to sign a contract, but the sales person may only sign when both of the customers have completed their signatures. 

In this scenario the request would consist of three tasks (one for each signatory), so lets call them task A, B and C.

  • first option is to let the two customers sign in parallel, this would be achieved by letting task C depend on task A and B
  • alternatively all signatures could be sequential, this could be achieved by letting task B depend on A, and task C depend on B


Changing an existing request

There could be various reasons that you would want to change an existing request — the email address or mobile number of one of the signatories could have changed, the relevant signatories could change or the request could simply become obsolete. 

4 - Receive Status of the request

When the document order was created, you most likely defined a documentactionrequest in order for notifications and callbacks to notify your server (or other recipient) about actions being taken by the signee — whether it's a request being created, cancelled or completed. We provide three complementary mechanisms for this:

  1. Notification by redirect
  2. Notification by server-to-server callback
  3. Notification by messaging

All are optional and may be used independently.

Notification by redirect

When you're creating a document order, the documentactionrequest allows you to specify three different URLs where Signicat can redirect the end user when they have signed (or declined to sign) a document. These cover the following scenarios:

on-task-completeThe url where the end user should be returned when the task is completed.
on-task-cancelThe url where the end user should be returned if the task is cancelled.
on-task-postponeThe url where the end user should be returned if he chooses to postpone the task.
URL is used when


The URLs are specified for each signature order, and may contain HTTP parameters with session specific or transaction specific values. The end user will not be redirected at all if on-task-complete is missing in the request when a document has been signed.

HTTP redirection cannot be guaranteed, however; the end user may close his browser before the redirect has completed or network problems may prevent the HTTP request to reach your server.

Notification by server-to-server callback

The documentactionrequest allows you to specify a URL on your server that Signicat should call when a signature order is created or completed. Signicat's server will make an HTTPS call to this URL directly (or HTTP, but insecure HTTP calls are only supported in preprod). This is a server-to-server call, not involving the end user's browser at all. You may specify a static URL that should be used for all signature orders, or you may specify a different URL for each order. The URL may contain any number of parameters such as session specific parameters or user specific information. You may also add parameters for added security, such as a static or dynamic password. Signicat will always add the requestId in an extra HTTP parameter.

The HTTP call will be made by Signicat's server and will come from a fixed IP address. In order for these to work, Signicat must be informed about the destination IP address and port on your end, as our firewall blocks notifications to unknown IPs by default.

The notification is specified in the request with these values:

recipientThe URL that Signicat should call (with any HTTP parameters).
typeThe string "URL"

You may specify more than one notification if you want Signicat to make more than one callback. Delivery of the notification is guaranteed as long as your server is able to receive HTTP calls.

When doing server-to-server notification, you may choose to add additional security features to make the notification reliable. An example would be to:

  1. Create a one time token (a random number or string) for each request.
  2. Add the token to the callback url in a http parameter called i.e. "secure".
  3. When Signicat makes the callback, validate that the value of the parameter is correct.


This would protect against fake HTTP callbacks since senders of fake callbacks would not be able to guess the correct parameter value.

Notification by messaging

The documentactionrequest allows you to specify a (mobile) phone number or an email address where Signicat should send a message when a document order is created or completed — you may specify one or more notifications like this. Typical uses of this is to send a message to a back office address, send a message to the end user or even send a message to a local workflow system. Each message is specified in each request, and the text can be personalized or contain user specific information like customer number, transaction details and so forth. Delivery of the notification depends on the SMS and email infrastructure and cannot be guaranteed.

The notification is specified in the documentactionrequest with these values:

recipientPhone number (with country code prefix) or email address.
senderThe sender address.
headerSubject in email. Not used for SMS.
messageThe text message in the email or SMS.
typeThe string "SMS" or "EMAIL".


 An example can be found here: How to notify and get notified when a document order status changes

Notes about security

You should not depend on the correctness of the information you get in the notifications. The notification should be regarded as a "hint" about a possible status change in the signature order. You must always call getStatus on Signicat's web service after you have received a notification to get reliable, updated status information.

The "Notification by server-to-server callback" can be extended to include security mechanisms that would make the notification reliable. However, Signicat still recommends that you always call getStatus to get reliable information. The information you get in return from the getStatus web service call will always be correct and reliable.

Other web service calls

It is possible to get information about existing requests by using getStatus and getRequestHistory which, in combination, yields a precise picture of any given request's as well as related status events.

An example of this can be found here: How to check the status and result of a document order 

NOTE: getStatus can be used for checking status on selected request, but in general, polling should be avoided. Instead, notifications and callbacks should be used.

5 - Download the signed document from SDS/Signicat Archive

In order to do this, you should know about the different formats the signed document may take. This will be described in greater detail in the following section: Signature Output.


 Signature Output

With the signature request completed, the resulting file will vary depending on the eID infrastructure that produced the signature. Customers of Signicat have the choice of using the third-party output of the eID infrastructure, or use a packaging format like XAdES or PAdES which provides a number of benefits regarding security and usability. In this section, we'll explain the differences.



It is possible to select XAdES (XML Advanced Electronic Signature) as the output format of a signature. XAdES is an European ETSI standard that provides several benefits over most of the third-party output formats:

  • One common format 
  • Supports Long Time Validation
  • Contains relevant events related to the signature process
  • Contains the certificate status response


It is possible to create a PAdES (PDF Advanced Electronic Signature) after a completed signature process. The PAdES file is a PDF compliant with the PAdES standard, which means that anyone with a regular PDF reader can see what was signed, by whom, and how it was signed. Evidence of every completed signature is embedded within the PAdES, which enables evidence to be unfolded in case of a dispute. PAdES files are made from packaging XAdES files — it is therefore required that the utilized signature method creates a XAdES output instead of the third-party format.

Benefits of using PAdES are:

  • One common format
  • Contains the full evidence of the signature
  • Works as a container of multiple signatures on a document
  • Can be read by anyone with a PDF reader
  • Can be distributed to relevant third parties
  • Enables all parties of the agreement to possess it 


As mentioned above, utilizing PAdES requires packaging with our packaging service before the document may be handled further.

Packaging service

Our web service PackagingService is used to create PAdES files based on one or more XAdES (LTV-SDO) files. It is packaged according to the Packaging Policies specified for the relevant ID type. The source XAdES files can be referenced from a recent document order (OrderDocumentId), the Archive (ArchiveDocumentId) or from the Session Data Storage (SdsDocumentId). The resulting PAdES file is always retrieved from the Session Data Storage.

The following examples can help you get started with PAdES:

How to use the packaging service to create a PAdES from an LtvSDO

How to download a PAdES from SDS

Third-party output

The third-party output of the various eID infrastructures is not standardized, which means that there can be several different resulting files. Looking at some of the Scandinavian eIDs; Danish NemID uses XMLDSIG as the output format, Norwegian BankID uses SEID SDO and Swedish BankID uses PKCS#7.

Information about the different eID infrastructures can be found here: eID infrastructures

In order to view, interpret and validate the signed documents, the third-party output format typically requires a solution such as Signicat Viewer. Furthermore, the storage of the combined proof of signature (which includes certificate status at the time of signature as well as transaction events) calls for an archive solution such as Signicat Archive, which is tailor-made for handling digitally signed documents.

Receiving and storing the signed document

There are two fundamental options for handling of the signed document: Sending it to the Signicat Archive for storage, or downloading it to your own systems (and subsequently archiving or distributing the document as desired).

Sending to Signicat Archive

It is possible to specify in the signature request that the result of the signature order should be sent to Signicat Archive using "send-result-to-archive", as described in the reference documentation: DocumentService v3 - API

Documents stored in the Signicat Archive can be fetched or deleted from the Archive using ArchiveService, described in further detail here: ArchiveService v3 - API

An example of how to specify that originals and signings results should be archived in Signicat Archive can be found in the following guide: How to use store originals and signed documents in Signicat Archive

Downloading the signed document

When the send-result-to-archive option is set to false, the documents will be stored in Signicats Session Data Storage instead. This is a temporary storage; documents can be accessed and retrieved for some time after the request is completed.

An example of how this is done can be found in the following guide: How to download a PAdES from SDS

Document handling

Secure delivery of a PAdES document to an end user

Signed documents often contain sensitive information and it is therefore recommended that distribution of such document are made in a secure fashion. One way that this can be achieved is by making a request in DocumentService v1 - API where the PAdES document provided has the DocumentAction type of VIEW and where the end user is authenticated before he is allowed to view and download the PAdES document.

Signature Preservation 

It is recommended that signature preservation is considered when signed agreements are of high value or if it is necessary to keep them over a longer period of time. Resignature of electronically signed documents can happen on documents in Signicat archive and on documents stored in your own organization.


 Features and Customization

The end user experience when signing documents with Signicat Signature can be customized a great deal — both when it comes to visuals and features. The following section will provide an overview of these options.

Portal and visuals

The portal is where the user meets the login and signature processes, it can be used standalone or embedded into a web site.

Graphical Profiles

Graphical profiles are used to customize the visuals of the portal. Currently, this process has been standardized, allowing customers a baseline they are allowed to customize with backgrounds, logos and colors to their liking. More information about this can be found in the following section: How to work with graphical profiles.

Text library

All texts presented in the portal can be customized to fit the preferred languages of your company. While an array of different languages are already supported for different signature methods, you can request a CSV file from with the current default values and change them as needed. More information about this can be found in the following section: How to customize and localize texts

Synchronous vs. asynchronous signature operations


Our definition of a synchronous signature is when the end user is already interacting with a website and, as a result of their actions — are sent to Signicat's signature environment. An example could be a user filling out a form which leads them to an agreement that needs to be signed.

There are three options when it comes to authenticating the user before they sign:

  • Using a supported eID type
  • Single sign-on artifact (SSO)
  • No authentication

Instead of having to (re)authenticate the end user using an eID type when the user is redirected to Signicat, it is possible issue a single sign-on artifact (created in the request to DocumentService) which lasts for 30 seconds. This takes the form of a small text string which is appended to the task URL. When the end user is redirected to Signicat, the user will be authenticated and therefore does not have to login.

In order so maintain appropriate security, it is generally recommended that the end user is authenticated (either with eID or an artifact) before they are allowed to see and sign the document(s).


How to allow anyone to view and sign the document

How to use artifacts to secure document orders

How to create and append new artifacts after the document order is created

How to require the user to authenticate before signing



Our definition of an asynchronous signature is when the user is notified of a pending signature, and subsequently starts the signature process when they so desire. The user is sent a reference to the signature task either as a URL or a reference code that can be used to get to the task. The user can get access to the document with or without authentication with a supported eID method prior to seeing and signing the document.

Notifications to end users can be handled by Signicat signature services or by your own systems depending on your preference. You can choose to notify the user using DocumentService with either email or SMS notifications.


How to notify and get notified when a document order status changes



By default, the portal is located at — but to give the best user experience (and to avoid browser alerts when iframing Signicat's solution into your web site) it is recommended to establish a subdomain. Signicat offers Signicat Subdomain, which allows customers to run their complete integration with id.signicat in their own subdomain.

These are some of the advantages of having a Signicat subdomain:

  • As opposed to our standard solution, the log-in and signature web pages will appear to belong to the company itself. The end user will get the feeling of being on the same website when logging in or signing documents, and not sent to another unknown site during these processes. There is still a redirection, but it is less intrusive and will give a more unified user experience.
  • The need for accepting third-party session cookies in the end users' browser disappears. Without the use of subdomain, third-party session cookie acceptance must be set in browsers when Signicat's authentication service is accessed through an iframe. (different isssues regarding the use of iframes is covered on this page).


For more information about setting up subdomains, please refer to the following documentation: Signicat Subdomain


Forms enable signatories to fill out a form and subsequently sign it with the ID method(s) specified in the request, allowing for simple forms to be filled as part of the signature process.

Forms are fundamentally comprised of an HTML form that is hosted on Signicats platform, as well as a PDF form in which the input from the signatory is merged into. The data that the user enters can be retrieved as structured data together with the signed PDF form. Multiple forms per service is supported.

For more information, please refer to the following document: Signicat Forms

Multiple documents

An agreement often consist of more than one document, which is why Signicat Signature provides an efficient and user friendly user interface for digital signature of document packages with multiple documents.

The user interface is designed to provide an easy and secure user experience, guiding the user step-by-step with detailed instructions and simple choices. This increases the likelihood of users completing signature tasks, as well as decreasing the number of users contacting your support centre. The documents to be signed may be mandatory or optional —you may also include documents that should merely be opened and viewed.

Multiple document support is utilized seamlessly the same web service interface as single document signature flows — simply add the required tasks to the signature request.

More information about tasks can be found in the following documentation: DocumentService v3 - API


Wizard-like process

The user interface is designed to guide the user through a possibly complex process step by step. The user will always be presented for simple choices in a clear and informative way. They will also have the option to see through all the documents before they start signing the first document, and start over again if something goes wrong.

Mandatory and optional documents

You may tag each document as mandatory or optional. The user is required to sign mandatory documents and will not be able to proceed to the next document as long as a mandatory document is unsigned. An optional document may be skipped.

Informational documents

A document can be merely informational, and as such can be included only for viewing. These can also be tagged as mandatory or optional.

Focus on user confidence

The user may always choose to read through all documents before he starts to sign the first document. The signed documents are not delivered before the user has completed and confirmed by pressing the "Send in" button. The user may always choose to restart the process or simply refuse to sign. We believe that providing this as clear options increases the user confidence and actually increases the likelihood of the user completing the task.


Signature flows with multiple documents provide the same web service interface and integration techniques as single document signature flows, and as such is also based on neutral protocols like HTTP, XML and SOAP.


Packaging Service Templates

The packaging service will take one or more signed XAdES documents as input and produce one PAdES (PDF) document with a visual representation of the original documents and signatures. The resulting PAdES document may also include a description of the documents, signers and signatures. It is fully possible to customize the information that will be presented, as well as the graphical layout. This is done by defining one or more PDF templates containing dynamic fields, which are then merged with values from the incoming XAdES files, and combined to generate the resulting PAdES document.

Templates are configured into your Signicat service in communication with Signicat Operations.

More information about PAdES templates here: Customizing PAdES with templates


If you'd prefer to read the guide in a separate window, you can click here.

 Packaging policy for Long Term Validation

Policy ID and location

Policy ID



Policy for Packaging of NemID E-Signatures for Long-Term Validation 



This packaging service policy defines requirements for packaging of NemID E-signatures for long-term validation in connection with the signature creation and initial verification. It includes requirement for collecting and packaging of the signers CPR-number.

About Packaging Policies

The purpose of a packaging policy is to specify requirements for the packaging process, and high-level requirements for the prior signature creation and verification process. 

The primary users of this policy will be e-signature users (relying parties). The policy will help e-signature users to better understand the information contained in a package, and on what basis it can be trusted and used.

The policy will also be useful for implementers of the packaging service.


This packaging policy defines requirements for packaging of NemID E-signatures for long-term validation in connection with the signature creation and initial verification.

The policy also sets some high level requirements for the creation and verification processes, and requires them to collect certain data that is needed by the packaging process. 

The policy does not set detailed requirements for the signature creation and verification processes, because those requirements are controlled by NemID.


The normative parts of the policy are listed below.

  1. General process requirement defines high-level requirements for the overall packaging process.
  2. Signature creation requirement defines requirements for the creation of the packaged signature (the “native” signature).
  3. Signature verification requirements verification defines requirements for the verification of the native signature. 
  4. Signature enrichment and hardening requirements  defines requirements for the signature enrichment and hardening process. 
  5. Package formatting requirements defines requirements for the format used for the package
  6. Sealing requirements defines requirements for the TSP signature on the package



  1.  Policy ID and location 1
  2.  Version 1
  3.  Introduction 1
  4.  General process requirements (normative) 3
  5.  Signature creation requirements (normative) 4
  6.  Signature verification requirements (normative) 4
  7.  Signature enrichment and hardening requirements (normative) 4
  8.  Package formatting requirements (normative) 6
  9.  Sealing requirements (normative) 6
  10.  Appendix A: Trust anchors used in validation of the native signature 7
  11.  Appendix B: Trust anchors used in validation of the seal 8


Terms and acronyms




Trusted Service Provider - the entity implementing this policy by packaging the signature.

Long-term validation

The concept of validating an e-signature long time (months, and some times years) after it was created. 

Native signature

The e-signature that is to be packaged for long-term validation

Original document

The document signed with the native signature

Signature enrichment


The addition of extra information about the document, the signer, the context or the signing and verification process. 

Signature hardening 

The addition of information that strengthens the non-reputability of the signature.

Native signature qualifying properties 

A common term for information that strengthens the native e-signature and makes it suitable for long-term validation.


This is the Trusted Service Providers signature on the package. It is commonly referred to as the Seal .


OCES Personal Certificates


OCES Employee Certificates



Short name




ETSI TS 101 903: “XML Advanced Electronic Signatures (XAdES)

General process requirements (normative)

  1. Packaging of the native signature is done such that it provides support for long-term validation of the native signature. 
  2. Packaging is performed immediately following signature creation and initial verification.
  3. Packaging is done only if initial verification succeeds.
  4. Validation data used in the initial verification is included in the package.

Signature creation requirements (normative)

This section defines requirements for the creation of the packaged signature (the “native” signature).

  1. The signers certificate must be of type POCES (not MOCES).
  2. The original document can be either on plain text format or PDF format.
  3. Signature creation is performed according to the NemID requirements and guidelines at signature creation time. 
  4. Signing of PDF documents is done as follows:
    1. Before the NemID client is launched the PDF is shown to the user.
    2. Then the PDF is Base64-encoded and put into the signproperties applet parameter with property name attachedpdf
    3. The signtext parameter is set to a text which declares that the user commits to the PDF which he has just read. This text is shown to the signer in the NemID client.

Signature verification requirements (normative)

This section defines requirements for the verification of the native signature.

  1. Signature verification is done according to current NemID requirements and guidelines at signature verification time.
  2. The process will always include verification of signature according to XMLDSig Core Validation [XMLDSIG]
  3. The process will include certificate validation of the signing certificate, including revocation check. Trust anchors used in certificate validation are listed in Appendix A.

Signature enrichment and hardening requirements (normative)

This section defines requirements for the signature enrichment and hardening done as part of the packaging. 

Native Signature Qualifying Properties

The following information is included in the package as native signature qualifying properties:

  1. The revocation information that was used in the initial verification of the native signature.
  2. All certificates that was used in initial verification, when not already included in the native signature.
  3. The signing time, as collected by the TSP from a trusted time source.

Signature creation context

The following information is collected from the signature creation context

Information about the client platform:

  1. Client OS and browser, as provided by the client browser.
  2. Client Java version

Information about the server platform:

  1. Server OS and Java version
  2. List of important server software components with versions

Signature verification context

The following information is collected from the signature verification context:

Information about the client platform:

  1. Client OS and browser, as specified by the browser through the HTTP Header “User-Agent”
  2. Client Java version

Information about the server platform:

  1. Server OS and Java version
  2. Version of the NemID API used (“OOAPI”)
  3. List of important server software components with versions

Signature external context

The following information is collected from the signature external context:

  1. The description of the external context as provided by the user of the packaging service.

Additional information

The following additional information elements are collected:

  1. The signers CPR, either by collecting it directly from the PID-CPR service, or by first collecting it from the user and then verify it against the PID-CPR service. 

Audit trail 

Audit trail entries are collected for important events, for the purpose of strengthening the non-reputability of the signature, and to support forensics. This could include events like, for example:

  1. “PDF shown to the signer”
  2. “Signature created”
  3. “Signature core validation succeeded”
  4. “Certificate path validation succeeded”
  5. “Revocation check succeeded” 
  6. “CPR collected from user and verified by PID-CPR service”, or “CPR collected from PID-CPR service”

Package formatting requirements (normative)

Package formatting is the process of putting all information elements together in a package.


The package must be formatted according to the following format specification:


Long Time Validation extended Signed Data Object 

Version *)


Available at *)


*) The 'X' means that the minor version number is not specified. It should be replaced by the actual minor version in the URL.

Sealing requirements (normative)

This section contains requirements to the TSP signature on the package, also called the seal.

  1. The seal covers the complete package, such that all information in the package is protected by the signature.
  2. The seal is a XAdES signature.
  3. The signature is verified immediately following signature creation.
  4. Signature verification is done according to XMLDSig Core Validation [XMLDSIG]
  5. Verification includes certificate validation of the signing certificate, including revocation check. Trust anchors used in certificate validation are listed in Appendix B.
  6. All certificates and revocation values used in the initial verification of the signature are included in the XAdES structure.
  7. The signature does not include time-stamps.
  8. The package is signed according to an explicit signature policy which is available together with this policy. 



Appendix A: Trust anchors used in validation of the native signature

The following certificate is used as trust anchor in Certificate Path Validation and OCSP Response validation when validating the native signature. 

TRUST2408 OCES Primary CA





































Appendix B: Trust anchors used in validation of the seal

The following certificates are used as trust anchor in Certificate Path Validation and OCSP Response validation when validating the seal (the TSP signature).

Buypass Class 3 CA 1






















Buypass Class 3 CA 1 - extended life-time






















Buypass Class 3 Root CA
































 Creating a simple document order with one subject

The C# example has been updated for compatibility with DocumentService-v3



 NemID.js FAQ
Unable to render {include} The included page could not be found.

NemID for citizens

NemID offers a free-of-charge secure identification of all Danish citizens, but with a transaction-fee for the merchant. NemID has already to a widely extend, replaced the older Danish Digital Signature for citizens and will continue to do so.

The NemID ID solution guarantees the identification of sender and receiver of information, and ensures secure encryption of personal internet transactions and e-mails. NemID can be used from any computer regardless of where in the world the user are, as long as the as long as the user has the code card.

The Signicat integration can include a lookup in the "PID/CPR-service", which returns the CPR number of the end-user. Please contact Signicat for establishing an agreement for the use of NemID.

NemID Employee signature

The NemID Employee signature is expected to be launched by DanID late 2011. It targets private enterprises as well as government agency’s and authority’s.

The NemID Employee signature is available to all Danish enterprises having a Danish CVR number. Though the first 3 NemID Employee Signatures are free of charge, adding more options and complexity will result in a fee to DanID.

The NemID Employee signature is a personal signature and it identifies you as a employee in a specific enterprise.

To be able to use this infrastructure (e.g. verifying a login or checking validity of e-mail signing/encryption) a agreement/contract must be made between you, the customer, and DanID.

Signicats NemID integration

The technical integration with Id.signicat will be the same as with the other ID-solutions. If you already have an integration with Id.signicat, you may also integrate with NemID without any changes, except from the url your application sends to Id.signicat.

This assumes that there is no eID-specific management in your web application.

External sources