Legal Agreements

Last updated on 15 July, 2022 1:44 AM

Overview

AccelByte Cloud's Legal Agreement service has the power to manage legal documents such as Terms of Service, Privacy Policy, End User License Agreement (EULA), and even Marketing Preferences, such as whether a player would like to receive updates via email. You can create and manage documents with different versions and locales, then store them in the Admin Portal.

Legal Agreements can be uploaded to either a game namespace or to your publisher namespace. Any agreements uploaded to your publisher namespace will be applied to all of your games in Player Portal or Launcher, and players will only need to agree to them once, when creating their account for your platform.

Permissions

Permissions are used to grant access to specific resources within our services. Make sure your account has the following permissions before you attempt to manage legal agreements in the Admin Portal. For a full list of permissions that impact legal agreements management, see the Legal tab of the permissions reference.

Usage	Permission Tag	Action
Create a Legal Document	ADMIN:NAMESPACE:*:LEGAL	Create
Update a Legal Document	ADMIN:NAMESPACE:*:LEGAL	Update
Create a Country-Specific Policy	ADMIN:NAMESPACE:*:LEGAL	Update
Create a New Version of a Document	ADMIN:NAMESPACE:*:LEGAL	Create
Edit Document Version Details	ADMIN:NAMESPACE:*:LEGAL	Update
Publish a Document Version	ADMIN:NAMESPACE:*:LEGAL	Update
Retrieving Policies by Country	ADMIN:NAMESPACE:*:LEGAL	Read
Retrieving a Document Content	ADMIN:NAMESPACE:*:LEGAL	Read

Permissions work slightly differently depending on whether they are assigned to IAM Clients or Roles assigned to users. For more information, read the Authentication and Authorization documentation.

Manage Legal Agreements in the Admin Portal

Create a Legal Document

To use AccelByte Cloud's Legal Agreements service, first you must create a legal document in the Admin Portal. This document acts as a container that you can upload the actual contents of the document into. To create this document, follow the steps below:

In the Admin Portal, go to Platform Configurations and click Legal Documents.
On the Legal Documents page you can see a list of all existing Legal Documents. To create a new document, click Create Document.
The Create Document form appears. Fill in the required fields:
- Input a name for the legal document in the Document Name field. Only letters and spaces are allowed.
- Choose the type of document you're creating from the Document Type dropdown menu. Choose Legal Document for legal documents such as Privacy Policies or Terms and Conditions. Choose Marketing Preference for marketing preferences such as the option for players to sign up for a newsletter.
- Select the namespace where the document will be created from the Namespace dropdown menu. To apply the document to a single game select that game's namespace, or to apply a document to all of your games select the publisher namespace.
- Select the countries that you want to create country-specific policies for later from the Country dropdown menu. The first country that you input will be the default country, so the documents uploaded later for this country will also apply to all countries that do not have their own country-specific policies.
  :::tip IMPORTANT You won't be able to delete countries later, so make sure your selections are correct before submitting this form. :::
- Input a tag for the document in the Tag field. This field is optional. Tags can be used to further classify documents.
- Select the client this legal document will be applied to in the Client field. In the publisher namespace, this could be Player Portal or Launcher, whereas in the game namespace this could be Steam, PSN, or other platforms. If left blank, the legal document will not appear in any platform.
  NOTE
  You can add additional clients to the legal document after it's created by opening the document and clicking Add More… next to Client.
- Input a description of the document in the Description field.
When you're finished, click the Create button. The new document will be added to the list.

Update a Legal Document

You can edit an existing legal document by following the steps below:

In the Admin Portal, go to Platform Configurations and click Legal Documents.
On the Legal Documents page you can see a list of all existing Legal Documents. Choose the document you want to update and click Update in that document's Action column.
The Update Document form appears. Make the desired edits to the fields below:
- Input a new name for the document in the Document Name field. Only letters and spaces are allowed.
- Select a new type for the document from the Document Type dropdown menu. Choose Legal Document for legal documents such as Privacy Policies or Terms and Conditions. Choose Marketing Preference for marketing preferences such as the option for players to sign up for a newsletter.
- Select a new country for the document to apply to from the Country dropdown menu.
- Input a new tag in the Tag field. This field is optional. Tags can be used to classify documents.
- Select a new client for this legal document to apply to from the Client dropdown menu. In the publisher namespace, this could be Player Portal or Launcher, whereas in the game namespace this could be Steam, PSN, or other platforms. If left blank, the legal document will not appear on any platform. You can select multiple clients.
- Input a new description of the document in the Description field.
Once completed, click the Edit button. The document will be updated.

Create a Country-specific Policy

After creating a legal document, you can create a country-specific policy to hold special versions of that document that are for specific countries. The countries that were entered when a legal document was created or edited will be listed as countries that require a specific version of that document. To add a new country-specific policy to that list, follow the steps below:

In the Admin Portal, go to Platform Configurations and click Legal Documents.
On the Legal Documents page you can see a list of all existing Legal Documents. Choose the document to which you want to add a new country-specific policy and click View next to that document.
On the Legal Document Details page, you can see the details of the selected Legal Document and the list of country-specific versions of that document. To create a new country-specific policy, click Add Policy.
The Add Policy form appears. Choose a country from the dropdown and click Create.
The country-specific policy is successfully created. You'll be redirected to the country-specific policy page that you just created.
To set this country as the default country for country-specific policies, click the Set as Default button.
If you want to require players to accept this policy before continuing to use the platform, select the Mandatory Update checkbox.

Create a New Version of a Document

After creating a country-specific policy, you can add a new version of that document anytime it's revised. To create a new version of a document, follow the steps below:

In the Admin Portal, go to Platform Configurations and click Legal Documents.
On the Legal Documents page you can see a list of all existing Legal Documents. Choose the document to which you want to add a new version and click View next to that document.
On the Legal Document Details page, you can see detailed information about the selected Legal Document and the list of country-specific policies related to that document. To create a new version of a country-specific policy, click View in the Action column of the country-specific policy you want to add a version to.
On the Country-Specific Policy page, you can see information about the policy and its existing versions. To create a new version of the document, click Create Version.
Enter a name for the new version in the Version Name field.
Once completed, click the Create button. The new document version will be created.
To add content to your new document version, click View in the Action column of that version.
On the Version Details page, you can see detailed information about the selected document version. To add content to this version, click Create New.
Select the language the document is in from the Locale dropdown menu. Then click Browse to find the document on your computer. The file should be in .md format.
Once completed, click the Create button. The selected file will be uploaded.

Edit a Document Version

You can edit the content of a legal document. To do so, follow the steps below:

In the Admin Portal, go to Platform Configurations and click Legal Documents.
On the Legal Documents page you can see a list of all existing Legal Documents. Choose the document you want to edit and click View next to that document.
On the Legal Document Details page, you can see detailed information about the selected Legal Document and the list of country-specific versions of that document. To open one of these country-specific policies, click View next to it.
On the Country-specific Policy page, you can see detailed information about the policy and existing versions of it. To edit a version, click View next to the version you want to edit.
On the Version Details page, use the text editor on the left side of the page to make your edits. The text box on the right side shows you how your changes will look after they're published.
Once completed, click Save.

Publish a Document Version

After you create a legal document, you can publish the legal document for all players in the affected namespace. To do so, follow the steps below:

In the Admin Portal, go to Platform Configurations and click Legal Documents.
On the Legal Documents page you can see a list of all existing Legal Documents. Choose the document that you want to publish and click View in that document's Action column.
On the Legal Document Details page, you can see detailed information about the selected Legal Document and the list of country-specific versions of it. Click View next to the country-specific policy you want to publish.
On the Country-specific Policy page, you can see detailed information about the policy and existing versions of it. To publish a version, click Publish next to that version.
A confirmation window will appear. Type PUBLISH in all caps and select the checkbox if you want to notify players about the policy update via email.
Once completed, click Publish. The new version will be published.

Implement Legal Agreements Using the Client SDKs

The Legal Agreement API can be called by using the functions in AccelByte::FRegistry::Agreement.

Check Player Eligibilities

Check all players' legal eligibility from a specified namespace. Use this function to check whether the logged in player has already agreed to the legal agreement.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.QueryLegalEligibilites(
  /* specified namespace */
  ,
  THandler < TArray < FAccelByteModelsRetrieveUserEligibilitiesResponse >> ::
  CreateLambda(
    [](TArray < FAccelByteModelsRetrieveUserElegibilitiesResponse > Result) {
      /* do something when succeeded */
    }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

string namespace_ = "publisherNamespace";
Result < RetrieveUserEligibilitiesResponse[] > EligibilitiesResult = null;
AccelBytePlugin.GetAgreement().QueryLegalEligibilities(namespace_, result => {
  EligibilitiesResult = result;
});

while (EligibilitiesResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

bool isEligible = true;
foreach(var eligibility in EligibilitiesResult.Value) {
  if (!eligibility.isAccepted) {
    isEligible = false;
    break;
  }
}

Retrieve Policies

Retrieve all latest active policies based on the namespace from the game configuration and country code from the user's profile.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.GetLegalPolicies(
  /* specified policy type */
  ,
  /* default on empty flag */
  ,
  THandler < TArray < FAccelByteModelsPublicPolicy >> ::
  CreateLambda([](TArray < FAccelByteModelsPublicPolicy > Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

Result < PublicPolicy[] > publicPoliciesResult = null;

AccelBytePlugin.GetAgreement().GetLegalPolicies(AgreementPolicyType.EMPTY, false, result => publicPoliciesResult = result);

while (publicPoliciesResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

if (!publicPoliciesResult.IsError) {
  /* do something when succeeded */
} else {
  /* do something when fails */
}

Retrieve List of Policies by Namespace

Retrieve all latest active policies from a specified namespace and country code from the user's profile.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.GetLegalPolicies(
  /* specified namespace */
  ,
  /* specified policy type */
  ,
  /* default on empty flag */
  ,
  THandler < TArray < FAccelByteModelsPublicPolicy >> ::
  CreateLambda([](TArray < FAccelByteModelsPublicPolicy > Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

string namespace_ = "publisherNamespace";
string[] tags = new string[] {
  "game",
  "NDA"
};
bool defaultOnEmpty = true; // will get default country when no localized policy for your country
Result < PublicPolicy[] > publicPoliciesResult = null;
AccelBytePlugin.GetAgreement().GetLegalPolicies(namespace_, AgreementPolicyType.EMPTY, tags, defaultOnEmpty, result => {
  publicPoliciesResult = result;
});

while (publicPoliciesResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

foreach(var publicPolicy in publicPoliciesResult.Value) {
  Debug.Log("PolicyName: " + publicPolicy.policyName + " | Description: " + publicPolicy.description);
  foreach(var policyVersion in publicPolicy) {
    Debug.Log("PolicyVersion: " + policyVersion.displayVersion + " | LocalizedPolicyUrl: " + policyVersion.localizedPolicyVersions[0].attachmentLocation);
  }
}

Retrieve List of Policies by Tag

Retrieve all latest active policies that have specified tags based on the namespace from game configuration and country code from the user's profile.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.GetLegalPolicies(
  /* specified policy type */
  ,
  /* list of tags */
  ,
  /* default on empty flag */
  ,
  THandler < TArray < FAccelByteModelsPublicPolicy >> ::
  CreateLambda([](TArray < FAccelByteModelsPublicPolicy > Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

Result < PublicPolicy[] > publicPoliciesResult = null;
string[] tags = new string[2] {
  "beta",
  "newsletter"
};

AccelBytePlugin.GetAgreement().GetLegalPolicies(AgreementPolicyType.EMPTY, tags, false, result => publicPoliciesResult = result);

while (publicPoliciesResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

if (!publicPoliciesResult.IsError) {
  /* do something when succeeded */
} else {
  /* do something when fails */
}

Retrieve List of Policies by Country

Retrieve all latest active policies based on a specified country and the namespace from game configuration.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.GetLegalPolicies(
  /* specified country code */
  ,
  /* specified policy type */
  ,
  /* default on empty flag */
  ,
  THandler < TArray < FAccelByteModelsPublicPolicy >> ::
  CreateLambda([](TArray < FAccelByteModelsPublicPolicy > Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

string countryCode = "US"; // You can get the country code from eligibilities return
string[] tags = new string[] {
  "game",
  "NDA"
};
bool defaultOnEmpty = true; // will get default country when no localized policy for your country
Result < PublicPolicy[] > publicPoliciesResult = null;
AccelBytePlugin.GetAgreement().GetLegalPoliciesByCountry(countrycode, AgreementPolicyType.EMPTY, tags, defaultOnEmpty, result => {
  publicPoliciesResult = result;
});

while (publicPoliciesResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

foreach(var publicPolicy in publicPoliciesResult.Value) {
  Debug.Log("PolicyName: " + publicPolicy.policyName + " | Description: " + publicPolicy.description);
  foreach(var policyVersion in publicPolicy) {
    Debug.Log("PolicyVersion: " + policyVersion.displayVersion + " | LocalizedPolicyUrl: " + policyVersion.localizedPolicyVersions[0].attachmentLocation);
  }
}

Retrieve List of Policies by Country and Tag

Retrieve all latest active policies that have specified tags based on a specified country and the namespace from game configuration.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.GetLegalPolicies(
  /* specified country code */
  ,
  /* specified policy type */
  ,
  /* list of tags */
  ,
  /* default on empty flag */
  ,
  THandler < TArray < FAccelByteModelsPublicPolicy >> ::
  CreateLambda([](TArray < FAccelByteModelsPublicPolicy > Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

string countryCode = "US";
string[] tags = new string[2] {
  "beta",
  "newsletter"
};
Result < PublicPolicy[] > publicPoliciesResult = null;

AccelBytePlugin.GetAgreement().GetLegalPolicies(countryCode, AgreementPolicyType.EMPTY, tags, false, result => publicPoliciesResult = result);

while (publicPoliciesResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

if (!publicPoliciesResult.IsError) {
  /* do something when succeeded */
} else {
  /* do something when fails */
}

Retrieving a Document's Content

Get the Content from a Legal Document

Use this function to retrieve the content of the specified document.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.GetLegalDocument(
  /* specified url */
  ,
  THandler < FString > ::CreateLambda([](FString Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

Result < string > docResult = null;
String localizedPolicyUrl = policyVersion.localizedPolicyVersions[0].attachmentLocation; // From GetLegalPolicies Result
AccelBytePlugin.GetAgreement().GetLegalDocument(localizedPolicyUrl, result => {
  docResult = result;
});

while (docResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

if (!docResult.IsError) {
  /* do something when succeeded */
} else {
  /* do something when fails */
}

Accepting Policies

Accept a Policy

Use this function to accept a localized policy document by providing the localized policy version ID.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.AcceptPolicyVersion(
  /* specified localized policy version Id */
  ,
  FVoidHandler::CreateLambda([]() {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

Result acceptPolicyVersionResult = null;
string localizedPolicyVersionId = policyVersion.localizedPolicyVersions[0].id; // From GetLegalPolicies Result
AccelBytePlugin.GetAgreement().AcceptPolicyVersion(localizedPolicyVersionId, result => acceptPolicyVersionResult = result);

while (acceptPolicyVersionResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

if (!acceptPolicyVersionResult.IsError) {
  /* do something when succeeded */
} else {
  /* do something when fails */
}

Accept Policies in Bulk

Use this function to accept many localized policy documents at once.

Unreal Engine
Unity

AccelByte::FRegistry::Agreement.BulkAcceptPolicyVersions(
  /* list of localized policy versions */
  ,
  THandler < FAccelByteModelsAcceptAgreementResponse > ::
  CreateLambda([](FAccelByteModelsAcceptAgreementResponse Result) {
    /* do something when succeeded */
  }),
  FError::CreateLambda([](int32 ErrorCode, FString ErrorMessage) {
    /* do something when fails */
  })
);

Result < AcceptAgreementResponse > acceptAgreementResponseResult = null;
List < AcceptAgreementRequest > acceptAgreementRequests = new List < AcceptAgreementRequest > ();
AcceptAgreementRequest acceptAgreementRequest = new AcceptAgreementRequest {
  isAccepted = true,
    policyId = policy.policyId,
    policyVersionId = policyVersion.id,
    localizedPolicyVersionId = policyVersion.localizedPolicyVersions[0].id
};
acceptAgreementRequests.Add(acceptAgreementRequest);

AccelBytePlugin.GetAgreement().AcceptPolicyVersion(localizedPolicyVersionId, result => acceptAgreementResponseResult = result);

while (acceptAgreementResponseResult == null) {
  yield
  return new WaitForSeconds(0.2 f);
}

if (!acceptAgreementResponseResult.IsError) {
  /* do something when succeeded */
} else {
  /* do something when fails */
}

Connect Custom Services to Legal Services using the Server SDKs

SDK Initialization

Before using the Legal service from the SDK, you will need to initialize your server-side SDK to ensure you are authorized and able to perform create, read, update, and delete actions.

Golang SDK Initialization

Before using the Legal service from the Golang SDK, you will need to initialize the SDK by following the steps below:

Create your OAuth Client and assign the necessary permissions to access the IAM service.
Log in as a Client using the SDK.
Initialize the OAuth 2.0 service using the following function:

Golang

agreementService := &legal.AgreementService{
    Client:          factory.NewLegalClient(&repository.ConfigRepositoryImpl{}),
    TokenRepository: &repository.TokenRepositoryImpl{},
}

Once completed, you can use the Golang SDK to create, read, update, or delete the Legal service from your serverless app.

Golang test case files

Python SDK Initialization

Before using the Legal service from the Python SDK, you need to initialize the SDK by making sure that you've done the following requirements.

Create your OAuth Client and assign the necessary permissions to access the Matchmaking service.
Log in as a Client using the SDK.

On a successful initialization, you can use the Python SDK to create, read, update and delete Legal from your serverless app.

To use the Legal Service, make sure you have the necessary permissions.

Python test case files

.NET (C#) SDK Initialization

Before using the Legal service, you will need to set some permissions. Use the following .NET namespaces:

    using AccelByte.Sdk.Api.Legal.Model;
    using AccelByte.Sdk.Api.Legal.Operation;
    using AccelByte.Sdk.Api.Legal.Wrapper;

.NET (C#) test case files

Java SDK Initialization

Before using the Legal service, you will need to set some permissions. Initialize the Agreement wrapper from the Legal service using the following code:

Agreement wLegalAgreement = new Agreement(sdk);

Once completed, you can use the SDK to create, read, update, or delete agreements.

Java test case files

Bulk Accept Policy Versions

Use the following function to bulk accept policy versions:

Golang
Python
C#
Java

err := dataRetrievalService.SaveAdminEmailConfiguration(input)
if err != nil {
  return err
}
return nil

from accelbyte_py_sdk.api.legal import bulk_accept_versioned_policy
from accelbyte_py_sdk.api.legal.models import AcceptAgreementRequest

result, error = bulk_accept_versioned_policy(
   body=[
       AcceptAgreementRequest.create(
           is_accepted=True,
           localized_policy_version_id="<localized_policy_version_id>",
           policy_id="<policy_id>",
           policy_version_id="<policy_version_id>"
       )
   ]
)
if error:
   print(error)

Agreement wLegalAgreement = new Agreement(sdk);

List<AcceptAgreementRequest> policies = new List<AcceptAgreementRequest>();
policies.Add(new AcceptAgreementRequest()
{
    PolicyId = "<policy_id>",
    PolicyVersionId = "<version_id>",
    LocalizedPolicyVersionId = "<localized_id>",
    IsAccepted = true
});

AcceptAgreementResponse? resp = wLegalAgreement.BulkAcceptVersionedPolicy(
    BulkAcceptVersionedPolicy.Builder
    .SetBody(policies)
    .Build());

List<AcceptAgreementRequest> request = Arrays.asList(AcceptAgreementRequest.builder()
                        .localizedPolicyVersionId(localizedPolicyVersionId)
                        .policyVersionId(policyVersionId)
                        .policyId(policyId)
                        .isAccepted(true)
                        .build());

wLegalAgreement.bulkAcceptVersionedPolicy(BulkAcceptVersionedPolicy.builder()
                        .body(request)
                        .build());

Retrieve Agreements

Use the following function to retrieve agreements:

Golang
Python
C#
Java

ok, err := agreementService.RetrieveAgreementsPublic()
if err != nil {
  return err
}
return nil

from accelbyte_py_sdk.api.legal import retrieve_agreements_public

result, error = retrieve_agreements_public()
if error:
   print(error)

Agreement wLegalAgreement = new Agreement(sdk);

List<RetrieveAcceptedAgreementResponse>? aggrs = wLegalAgreement.RetrieveAgreementsPublic(
    RetrieveAgreementsPublic
    .Builder.Build());

List<RetrieveAcceptedAgreementResponse> aggrs = wLegalAgreement
                                .retrieveAgreementsPublic(RetrieveAgreementsPublic.builder().build());

Use the following function to update marketing preference consent:

Golang
Python
C#
Java

err := agreementService.ChangePreferenceConsent()
if err != nil {
  return err
}
return nil

from accelbyte_py_sdk.api.legal import change_preference_consent
from accelbyte_py_sdk.api.legal.models import AcceptAgreementRequest

result, error = change_preference_consent(
   body=[
       AcceptAgreementRequest.create(
           is_accepted=True,
           localized_policy_version_id="<localized_policy_version_id>",
           policy_id="<policy_id>",
           policy_version_id="<policy_version_id>"
       )
   ]
)
if error:
   print(error)

Agreement wLegalAgreement = new Agreement(sdk);

List<AcceptAgreementRequest> aggreementRequests = new List<AcceptAgreementRequest>()
{
    new AcceptAgreementRequest()
    {
        LocalizedPolicyVersionId = targetLocalizedPolicyId,
        PolicyVersionId = targetPolicyVersionId,
        PolicyId = targetPolicyId,
        IsAccepted = true
    }
};

wLegalAgreement.ChangePreferenceConsent(
    ChangePreferenceConsent.Builder
    .SetBody(aggreementRequests)
    .Build());

List<AcceptAgreementRequest> agreementRequests = Arrays.asList(new AcceptAgreementRequest[] {
                                AcceptAgreementRequest.builder()
                                                .localizedPolicyVersionId(localizedPolicyVersionId)
                                                .policyVersionId(policyVersionId)
                                                .policyId(policyId)
                                                .isAccepted(true)
                                                .build()
                });

wLegalAgreement.changePreferenceConsent(
                                ChangePreferenceConsent.builder()
                                                .body(agreementRequests)
                                                .build());

To learn more about GDPR and CCPA compliance, see the GDPR documentation.
Players are shown legal documents based on their country as defined in their player profile. To learn more about profiles, see the Profile documentation.

Overview​

Permissions​

Manage Legal Agreements in the Admin Portal​

Create a Legal Document​

NOTE

Update a Legal Document​

Create a Country-specific Policy​

Create a New Version of a Document​

Edit a Document Version​

Publish a Document Version​

Implement Legal Agreements Using the Client SDKs​

Check Player Eligibilities​

Retrieve Policies​

Retrieve List of Policies by Namespace​

Retrieve List of Policies by Tag​

Retrieve List of Policies by Country​

Retrieve List of Policies by Country and Tag​

Retrieving a Document's Content​

Get the Content from a Legal Document​

Accepting Policies​

Accept a Policy​

Accept Policies in Bulk​

Connect Custom Services to Legal Services using the Server SDKs​

SDK Initialization​

Golang SDK Initialization​

Python SDK Initialization​

.NET (C#) SDK Initialization​

Java SDK Initialization​

Bulk Accept Policy Versions​

Retrieve Agreements​

Update Marketing Preference Consent​

Related Concepts​

Overview

Permissions

Manage Legal Agreements in the Admin Portal

Create a Legal Document

Update a Legal Document

Create a Country-specific Policy

Create a New Version of a Document

Edit a Document Version

Publish a Document Version

Implement Legal Agreements Using the Client SDKs

Check Player Eligibilities

Retrieve Policies

Retrieve List of Policies by Namespace

Retrieve List of Policies by Tag

Retrieve List of Policies by Country

Retrieve List of Policies by Country and Tag

Retrieving a Document's Content

Get the Content from a Legal Document

Accepting Policies

Accept a Policy

Accept Policies in Bulk

Connect Custom Services to Legal Services using the Server SDKs

SDK Initialization

Golang SDK Initialization

Python SDK Initialization

.NET (C#) SDK Initialization

Java SDK Initialization

Bulk Accept Policy Versions

Retrieve Agreements

Update Marketing Preference Consent

Related Concepts