Decoding and Solving the Five Most Common SAML Errors

Configuring SAML-based SSO authentication is prone to a number of different types of errors, resulting in confusion for IT admins configuring your application or authentication issues for your end users. In this post, we will take a deep dive into the five most common SAML errors.

Security Assertion Markup Language (SAML) plays an integral role in facilitating single sign-on (SSO) authentication between a service provider (SP) and an identity provider (IdP). Configuring SAML-based SSO authentication is prone to a number of different types of errors, resulting in confusion for IT admins configuring your application or authentication issues for your end users.  In this post, we'll take a deep dive into the five most common SAML errors, in order of the frequency they are seen:

  1. Missing Attribute Errors
  2. Signature Validation Errors
  3. URL Not Found Errors
  4. Expired Response Errors
  5. IdP-initiated Specific Errors

We'll explain what causes each of these problems and how to resolve them.

1. Missing Attribute Errors

Missing attribute errors occur when the attributes defined by the IdP don't match those expected by the SP. In these cases, while attempting to authenticate via SSO, users may encounter an error message like "missing required attributes." There are two primary underlying reasons for missing attribute errors that we'll cover:

  1. The mapping between attributes defined in the IdP and the SP is incorrect
  2. There is missing attribute data in the IdP profile

Fixing Missing Attribute Errors caused by incorrect attribute mapping

During SSO authentication, the IdP returns a SAML response containing AttributeStatements. These elements contain Attribute elements with a Name property defined by the IdP.  A Missing Attribute Error may surface when the service provider expects a Name pattern that differs from the one defined in the IdP.  Keep in mind that these mappings are case sensitive.

For example, say the SP expects id, email, firstName, and lastName attributes. Let’s take a look at how this is mapped and configured in both Okta and Azure.


This is how the SP attributes map to Okta attributes:

id →

email →

firstName → user.firstName

lastName → user.lastName

In Okta, configure Attribute Statements id, firstName, lastName and email:

Once configured, the AttributeStatement  in Okta’s SAML response will look something like this:

<saml2:AttributeStatement xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">
    <saml2:Attribute Name="id" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>" xmlns:xsi="<>" xsi:type="xs:string">
    <saml2:Attribute Name="firstName" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>" xmlns:xsi="<>" xsi:type="xs:string">
    <saml2:Attribute Name="lastName" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>" xmlns:xsi="<>" xsi:type="xs:string">
    <saml2:Attribute Name="email" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>" xmlns:xsi="<>" xsi:type="xs:string">


In Azure, those attributes are mapped to different names than Okta. You can configure Attribute Statements for givenname, surname, emailaddress, and objectidentifier.

This is how SP attributes map to Azure profile attributes (note that attribute names in Azure are defined with a namespace by default):

Ensure that the claims are configured according to the defined mapping:

Once configured, the AttributeStatement in Azure’s SAML response will look something like this:

<saml2:AttributeStatement xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">
    <saml2:Attribute Name="" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>"
            xmlns:xsi="<>" xsi:type="xs:string">Michael</saml2:AttributeValue>
    <saml2:Attribute Name="" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>"
            xmlns:xsi="<>" xsi:type="xs:string">Appleseed</saml2:AttributeValue>
    <saml2:Attribute Name="" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>"
            xmlns:xsi="<>" xsi:type="xs:string"></saml2:AttributeValue>
    <saml2:Attribute Name="" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
        <saml2:AttributeValue xmlns:xs="<>"
            xmlns:xsi="<>" xsi:type="xs:string">14f5d2dc-885a-4ddf-915e-4abc314a3fa4</saml2:AttributeValue>

It is critical to ensure that the attributes are mapped precisely between the IdP and SP, but it's also possible to see these errors when data is missing.

Fixing Missing Attribute Errors caused by missing data

In some cases, the missing attribute error may result from missing attributes in the user's identity data. In such cases, the user's identity data must be updated to include the required attributes.

For example, in Azure, last name is always mapped to the surname claim. Notice that the Azure user in the following screenshot is missing the last name attribute. If the SP requires the surname attribute, this may be the cause of the missing attribute error, and the missing data should be added:

Missing attribute errors usually result from discrepancies in attribute mapping between the IdP and the SP or missing attribute data in the IdP. It's critical for Service Providers to keep their attribute mapping configuration up-to-date to prevent these errors from surfacing.

2. Signature Validation Errors

A SAML Signature Validation Error occurs when the SAML assertion signature from an IdP cannot be verified.

The IdP generates the SAML assertion signature using a private key. Once the SP receives a response from the IdP, it will verify the signature using the corresponding public key, typically an X.509 certificate. This process ensures the integrity of the SAML response — that it hasn't been tampered with during transit.

The most common causes of a Signature Validation Error are:

  • The IdP's public key certificate that the Service Provider has is missing, expired, or incorrect.
  • The SAML response or assertion was altered during transit.
  • The IdP's SAML response is signed in a way that the SP is not expecting.
  • The part of the IdP’s SAML response that is signed is different than expected.

Fixing SAML Signature Validation Errors

  1. Update the IdP's public certificate: Ensure the public certificate configured in your SP matches the one currently used by your IdP. If it has been updated or is incorrect, you'll need to obtain the correct certificate from your IdP and update it in your SP's SAML configuration.
  2. Check the signature location: Depending on the IdP, the SAML assertion or the entire SAML response can be signed. If your SP is expecting the a different portion of the response to be signed, it could cause a validation error. Check your SP's requirements and ensure the IdP's settings match.
  3. Ensure the SAML response is not altered: If the SAML response or assertion is altered during transit (even if a single character is changed), the signature will no longer match, causing a validation error. This might indicate a problem with the transmission of the SAML response between the IdP and SP. Investigate the network route, including any proxies, firewalls, or other components that could be interfering with the SAML response.
  4. Check the certificate expiry: Ensure that the IdP's public key certificate has not expired. If it has, you'll need to update it with a current, valid certificate.
  5. Verify configuration settings: Check the SP and IdP configurations to ensure their compatibility and correctness. This includes entity IDs, endpoints (like Assertion Consumer Service URL), NameID formats, and other SAML settings.

In all cases, the exact steps to follow will depend on your specific IdP and SP software, so refer to the relevant documentation for detailed instructions.

3. URL Not Found Errors

A URL Not Found or 404 error usually indicates that a resource is not found on the server. In the context of SAML, it may occur when the IdP or the SP is trying to reach a URL or endpoint that does not exist or is not properly configured. This could be the Single Sign-On URL, Single Logout URL, or another service URL.

Fixing 404 Error in SAML Configuration Errors

  1. Check Your URL/endpoint configuration: Make sure that all of the URLs or endpoints in your SAML configuration are correctly configured in both the IdP and the SP. This includes the Assertion Consumer Service (ACS) URL, Single Logout Service (SLS) URL, Entity ID, and others. The ACS URL could also be referred to under other names: Single Sign-on URL, Reply URL, SAML Assertion Endpoint, SAML Response Endpoint, SAML Callback URL, SP Assertion Consumer URI
  2. Ensure URLs are properly formatted: A small typo or formatting error can lead to a 404 error. Double-check each URL for typos, improper formatting, or incorrect protocol (http vs. https).
  3. Verify server accessibility: Ensure that the server hosting the IdP or SP is accessible from the public Internet if required. If it’s inaccessible, there may be a network or server configuration issue.
  4. Check server routing and redirection rules: Sometimes server configuration may redirect requests to different URLs or block certain paths. Make sure the server's routing rules are correctly set up to handle the SAML requests and responses.
  5. Inspect the IdP and SP Logs: The logs may provide more details about where and why the 404 error is occurring. They might point you to a specific misconfiguration or a part of the process that's failing.

Remember, the exact method for addressing these issues depends on your specific IdP and SP software, so refer to the relevant documentation for detailed instructions. Always be careful when modifying any security settings or configurations, as misconfigurations can create new vulnerabilities.

4. Expired Response Errors

An Expired Response Error in a SAML configuration typically refers to an issue with the SAML assertion's timing values, specifically the NotBefore and NotOnOrAfter conditions.

These conditions are found in <saml:Conditions>  in the IdPs SAML assertion. They define the time window during which the assertion is valid. Here's an example:

<saml2:Conditions NotBefore="2019-09-05T00:15:52.248Z" NotOnOrAfter="2019-09-05T00:25:52.248Z"

If the SP receives the assertion outside this time window, it will reject the assertion and may display an Expired Response Error. Fixing Expired Response Errors

  1. Check time synchronization: The most common cause of this issue is clock skew between the IdP and the SP. Both systems should have their clocks synchronized with a reliable time source, via Network Time Protocol for example, to ensure they agree on the current time.
  2. Increase assertion lifetime: If your users are experiencing this issue frequently, it could be due to the assertion's short validity period. In this case, you might need to increase the duration in the IdP's settings. Be aware, however, that increasing the assertion's lifetime potentially increases the risk of replay attacks.
  3. Reduce network latency: If there's significant network latency between the IdP and the SP, the assertion might expire before it reaches the SP. Look for ways to reduce this latency, which might involve network engineering outside the scope of the SAML configuration.
  4. Handle clock skew in SAML libraries: Some SAML libraries allow you to specify a "clock skew" value. This is the amount of time the library will allow for differences in the clocks of the two systems. Increasing this value can help if you're experiencing this issue but, like increasing the assertion's lifetime, it may also increase the risk of replay attacks.

Remember to carefully consider the security implications when changing these settings. If in doubt, seek advice from a security professional.

5. IdP-initiated Specific Errors

IdP-initiated SSO is a SAML flow in which the IdP initiates the authentication process, typically by providing a link that automatically authenticates a user and takes them to the specific SP. Common errors in IdP-initiated SAML configurations include:

  1. Incorrect RelayState parameter: The RelayState parameter is used in IdP-initiated SSO to specify where the user should be redirected after authentication. If this is incorrect, the user may be redirected to the wrong place, or the redirection might fail entirely. Ensure this value is correctly configured in your IdP.
  2. InResponseTo attribute included on IdP-initiated SSO: When using SP-initiated SSO, the InResponseTo attribute is used to connect the response to the original SAML request using its ID. However, if this attribute is found in IdP-initiated SSO, it creates an inconsistency because there is no SAML request. To avoid this issue, ensure that the IdP provider is not set up to send this attribute during IdP-initiated SSO.
  3. SP not configured for IdP-Initiated SSO: Not all SPs support IdP-initiated SSO, and even those that do might require specific configuration to enable or disable it. If IdP-Initiated is disabled or not supported, the SP should emit an error when receiving the SAML response.
  4. Incorrect Entity ID or Issuer: The IdP sends a SAML response to the SP that includes an issuer or entity ID to identify itself. If this value is incorrect, the SP may not recognize the IdP and reject the SAML response. Make sure the issuer or entity ID in your IdP's SAML responses matches what your SP expects.
  5. Mismatch in SAML version: Ensure both your IdP and SP are using the same SAML version (either SAML 2.0 or SAML 1.1). Mismatched versions can lead to errors.

To address these issues, you'll need to carefully review your IdP and SP configurations, ensure your users are correctly authenticating with the IdP, and potentially make changes to your application or your IdP or SP settings. Always refer to the documentation of your specific IdP and SP for detailed instructions.

Streamlining SAML with WorkOS

Dealing with SAML configurations is often a complex and error-prone process. Each IdP can have different requirements, and there are many points at which human errors can prevent a successful SSO setup.

One way to normalize IdPs and reduce error friction is by using WorkOS SSO. With easy-to-use APIs and just a few lines of code, you can integrate once with WorkOS and seamlessly offer SAML integrations with over 20+ different IdPs.

With the WorkOS Admin Portal, you can provide your customers’ IT admins a self-serve setup wizard. The Admin Portal’s interactive instructions are tailored to each IdP. And every set of instructions is updated regularly, which means no more sending out-of-date PDFs or spending hours of customer success time walking customers through every step. Once again, the traditional manual process of setting up SSO is fraught with human error, even when customer success is involved. Engineers often have to jump in, wasting resources that could be spent working on core product.

For times when errors arise and intervention is required, WorkOS identifies and guides IT admins through troubleshooting SAML-related errors:

Still having issues? Our dedicated Developer Success Engineering team will help you navigate the complexities of SAML and ensure you have all the resources you need to reduce onboarding friction with your largest enterprise customers.

By incorporating WorkOS into your application, you can drastically reduce the time and resources spent dealing with SAML errors, allowing your team to focus on what you do best: building outstanding applications.

In this article

This site uses cookies to improve your experience. Please accept the use of cookies on this site. You can review our cookie policy here and our privacy policy here. If you choose to refuse, functionality of this site will be limited.