Autenticação

Cadastro de usuário

A configuração padrão para Weblate é usar python-social-auth, um formulário no site para lidar com o registro de novos usuários. Depois de confirmar seu e-mail, um novo usuário pode contribuir ou autenticar usando um dos serviços de terceiros.

Você também pode desativar o registro de novos usuários usando REGISTRATION_OPEN.

As tentativas de autenticação estão sujeitas a Limitação de taxa.

Backends de autenticação

O Weblate utiliza Django para autenticação. Isso inclui autenticação integrada baseada em senha, autenticação social e backends de autenticação de terceiros para Django.

Usando a autenticação embutida do Django significa que você pode importar o banco de dados de usuários de outros projetos baseados no Django (consulte Migrando de Pootle).

Ver também

Configurações de autenticação descreve como configurar a autenticação na imagem oficial do Docker.

Teams from identity providers

Adicionado na versão 2026.10.1.

Weblate can synchronize selected teams from external group memberships or application roles during social authentication. The default native and Docker pipelines include synchronization after authentication checks and two-factor authentication. Extraction and assignment are disabled until configured. If you use a custom authentication pipeline, place social_core.pipeline.user.sync_groups after all authentication checks, including weblate.legal.pipeline.tos_confirm when terms acceptance is enabled.

Map external identifiers to lists of existing Weblate team IDs. Find team IDs in the administration interface URL or the teams REST API. Names can repeat across project and workspace scopes, so they are not used as mapping targets.

For Microsoft Entra ID, prefer application roles:

SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_GROUPS_KEY = "roles"
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_GROUPS_MAP = {
    "Weblate.Translator": [42],
    "Weblate.Reviewer": [43],
}

Configure the provider to issue these roles. Group identifiers can instead be selected with GROUPS_KEY = "groups". Group overage causes authentication to fail; Weblate does not retrieve memberships from Microsoft Graph. Restrict the trusted tenant and issuer before granting permissions, especially when using a common Azure endpoint.

For generic OpenID Connect or Keycloak, configure a literal claim name:

SOCIAL_AUTH_OIDC_GROUPS_KEY = "groups"
SOCIAL_AUTH_OIDC_GROUPS_MAP = {"translators": [42]}

SOCIAL_AUTH_KEYCLOAK_GROUPS_KEY = "groups"
SOCIAL_AUTH_KEYCLOAK_GROUPS_MAP = {"/organization/reviewers": [43]}

For GitLab, explicitly enable membership retrieval:

SOCIAL_AUTH_GITLAB_GROUPS_ENABLED = True
SOCIAL_AUTH_GITLAB_GROUPS_MAP = {"organization/translators": [42]}

Enabling retrieval automatically requests read_api unless read_api or api is already requested. Enable the corresponding permission in the GitLab OAuth application settings alongside read_user.

GitLab uses full group paths by default. Use stable numeric group IDs instead when paths might change or be reused:

SOCIAL_AUTH_GITLAB_GROUPS_IDENTIFIER = "id"
SOCIAL_AUTH_GITLAB_GROUPS_MAP = {"12345": [42]}

For SAML, add the group attribute and mapping to each existing entry in SOCIAL_AUTH_SAML_ENABLED_IDPS:

SOCIAL_AUTH_SAML_ENABLED_IDPS["company"].update(
    {
        "attr_groups": "https://example.com/claims/groups",
        "groups_map": {"translators": [42]},
        "allow_groups": ["translators", "reviewers"],
    }
)

All targets in a mapping become provider-managed teams. Authentication adds desired memberships and removes obsolete managed memberships. Unrelated teams and existing membership language restrictions are preserved. Changes are recorded in the audit log. Manual membership in a managed team is subject to replacement at the next authentication. A team may be managed by only one configured provider or SAML IdP; conflicting mappings and nonexistent teams cause errors before memberships change. No teams are created automatically.

A missing configured claim fails authentication. When a provider omits claims for users without assignments, explicitly enable its SOCIAL_AUTH_<BACKEND>_GROUPS_MISSING_AS_EMPTY setting. SAML uses groups_missing_as_empty in the IdP entry. An empty membership list removes all provider-managed memberships. An empty GROUPS_MAP disables assignment.

Login restrictions are independent of assignment. Configure SOCIAL_AUTH_<BACKEND>_ALLOW_GROUPS to require membership in any listed external group or role. Unknown identifiers grant nothing, but do not reject login unless an allow list is configured. Existing CAS allow lists require no new settings or pipeline entries.

Synchronization applies to login, registration, and authentication-method linking. Password reset and account removal do not synchronize teams. Updates occur only during authentication; this does not deactivate accounts or revoke access in the background. Synchronization does not store external membership snapshots.

In Docker installations, use Configuração além das variáveis de ambiente to supply these Python settings; there are no dedicated environment variables for team mappings.

Ver também

External groups

Autenticação social

Graças ao Welcome to Python Social Auth’s documentation!, o Weblate suporta autenticação usando muitos serviços de terceiros, como GitLab, Ubuntu, Fedora, etc.

Por favor, verifique sua documentação para as instruções de configuração genéricas em Django Framework.

Nota

Por padrão, o Weblate conta com serviços de autenticação de terceiros para fornecer um endereço de e-mail validado. Se alguns dos serviços que você deseja usar não suportarem isso, por favor, aplique a validação de e-mail no lado Weblate configurando FORCE_EMAIL_VALIDATION para eles. Por exemplo:

SOCIAL_AUTH_OPENSUSE_FORCE_EMAIL_VALIDATION = True

Ver também

Pipeline

Provider names are normalized by Python Social Auth’s social_names pipeline step before Weblate initializes an empty full name. Existing full names are preserved. Weblate cleans and limits the resulting name and falls back to the username when the provider name is missing or invalid.

SOCIAL_AUTH_FIRSTLAST_FROM_FULL and SOCIAL_AUTH_FULL_FROM_FIRSTLAST control name conversion and both default to True. Backend-specific settings are supported, for example SOCIAL_AUTH_SAML_FULL_FROM_FIRSTLAST = False. See Name normalization for the conversion rules. Custom SOCIAL_AUTH_PIPELINE configurations should include social_core.pipeline.social_auth.social_names after social_details.

Permitir backends individuais é bastante fácil, é apenas uma questão de adicionar uma entrada à configuração AUTHENTICATION_BACKENDS e possivelmente adicionar chaves necessárias para um determinado método de autenticação. Por favor, note que alguns backends não fornecem e-mails do usuário por padrão, você tem que solicitá-lo explicitamente, caso contrário o Weblate não será capaz de pagar corretamente as contribuições que os usuários fazem.

Dica

A maioria dos backends de autenticação exige HTTPS. Assim que o HTTPS estiver habilitado em seu servidor web, configure o Weblate para relatá-lo corretamente usando ENABLE_HTTPS ou, no contêiner Docker, WEBLATE_ENABLE_HTTPS.

Authentication storage cleanup

Weblate removes expired OpenID protocol associations and OpenID Connect login nonces in its hourly authentication cleanup task. OIDC login attempts have a 30-minute nonce lifetime by default; expiry is enforced during login even before the next cleanup runs. Linked accounts are preserved. Verification codes and partial pipelines retain their existing AUTH_TOKEN_VALID policy.

The social-auth database migration gives existing undated OIDC nonces a 30-minute grace period from upgrade. Follow the usual upgrade procedure with old login-serving processes stopped while applying migrations. For backend configuration, see OIDC (OpenID Connect).

Autenticação por OpenID

Para serviços baseados em OpenID, geralmente é apenas uma questão de habilitá-los. A seção a seguir permite a autenticação OpenID para OpenSUSE, Fedora e Ubuntu:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.email.EmailAuth",
    "social_core.backends.suse.OpenSUSEOpenId",
    "social_core.backends.ubuntu.UbuntuOpenId",
    "social_core.backends.fedora.FedoraOpenId",
    "weblate.accounts.auth.WeblateUserBackend",
)

Ver também

OpenID

Keycloak authentication

Register a client in Keycloak with the callback URL https://WEBLATE SERVER/accounts/complete/keycloak/. Follow Keycloak - Open Source Red Hat SSO for the client credentials, signing key, audience, and endpoint configuration. Add social_core.backends.keycloak.KeycloakOAuth2 to AUTHENTICATION_BACKENDS alongside the Weblate backends.

Use the stable subject claim to identify accounts:

SOCIAL_AUTH_KEYCLOAK_ID_KEY = "sub"
SOCIAL_AUTH_KEYCLOAK_LEGACY_ID_KEYS = ["email"]
SOCIAL_AUTH_KEYCLOAK_ALLOW_UNVERIFIED_LEGACY_UID_MIGRATION = False

Docker also uses sub with historical e-mail lookup, but enables compatibility migration when no identifier is explicitly configured, as described below. See the WEBLATE_SOCIAL_AUTH_KEYCLOAK_KEY configuration variables.

Aviso

E-mail addresses and usernames can change or be reassigned to another Keycloak account. Using either as ID_KEY can let the new owner access an existing Weblate account. E-mail verification does not prevent this reassignment risk.

Weblate relies on the provider to validate e-mail addresses, as described in Social authentication. If the realm does not enforce validation, configure SOCIAL_AUTH_KEYCLOAK_FORCE_EMAIL_VALIDATION = True. This controls e-mail validation and does not replace the stable account identifier.

Upgrading existing Keycloak associations

Earlier Docker configurations defaulted to email. Python Social Auth migrates existing associations to sub on the next successful login. When WEBLATE_SOCIAL_AUTH_KEYCLOAK_ID_KEY is unset, Docker enables SOCIAL_AUTH_KEYCLOAK_ALLOW_UNVERIFIED_LEGACY_UID_MIGRATION so that associations without a saved subject can migrate using their historical e-mail address or username. An explicit identifier disables this compatibility default, including an explicit sub. You can override the policy using WEBLATE_SOCIAL_AUTH_KEYCLOAK_ALLOW_UNVERIFIED_LEGACY_UID_MIGRATION. After migration, authentication matches the subject instead of the historical identifier. Conflicting saved subject evidence still stops authentication.

Aviso

Until an association migrates, its historical e-mail address or username remains sufficient to claim it. A different Keycloak account assigned that identifier could take over the association during migration. Once migrated, the association is bound to the subject and this fallback no longer applies.

To require saved subject evidence instead, set SOCIAL_AUTH_KEYCLOAK_ALLOW_UNVERIFIED_LEGACY_UID_MIGRATION = False in your Django settings, or set WEBLATE_SOCIAL_AUTH_KEYCLOAK_ALLOW_UNVERIFIED_LEGACY_UID_MIGRATION to 0 in Docker. Associations without this evidence then require recovery through another login method, removal of the stale association, and linking the identity again, or administrative repair using independently verified Keycloak records.

Before applying the Python Social Auth historical-key backfill migration, configure SOCIAL_AUTH_OLD_ID_KEYS with the identifier that actually created the associations. For example, for the historical Docker default:

SOCIAL_AUTH_OLD_ID_KEYS = {"keycloak": "email"}

Docker sets this mapping to email unless WEBLATE_SOCIAL_AUTH_KEYCLOAK_ID_KEY is explicitly configured, in which case it assumes that value also created the historical associations. This historical default is email even though the new active default is sub. If you change this variable during the upgrade, override the historical mapping separately using Substituindo as configurações do volume de dados. In particular, retain the historical sub mapping for deployments that already used subjects. Never infer the historical key from the identifier value alone.

If the migration has already assigned incorrect keys, changing SOCIAL_AUTH_OLD_ID_KEYS does not repair them. Audit and correct affected associations against trusted provider records. See Identifier migration for evidence requirements and backfill details. Explicit mutable identifier overrides remain supported, but must be changed to sub to obtain the protection described here.

Autenticação por GitHub

Você precisa registrar um aplicativo OAuth no GitHub e, em seguida, dizer ao Weblate todos os seus segredos:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.github.GithubOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITHUB_KEY = "GitHub Client ID"
SOCIAL_AUTH_GITHUB_SECRET = "GitHub Client Secret"
SOCIAL_AUTH_GITHUB_SCOPE = ["user:email"]

O GitHub deve ser configurado para ter URL de um retorno de chamada como https://WEBLATE SERVER/accounts/complete/github/.

Existem backends de autenticação semelhantes para o GitHub para Organizações e o GitHub para Equipes. Suas configurações são denominadas SOCIAL_AUTH_GITHUB_ORG_* e SOCIAL_AUTH_GITHUB_TEAM_*, e requerem configuração adicional do escopo – SOCIAL_AUTH_GITHUB_ORG_NAME ou SOCIAL_AUTH_GITHUB_TEAM_ID. Seus URLs de retorno de chamada são https://WEBLATE SERVER/accounts/complete/github-org/ e https://WEBLATE SERVER/accounts/complete/github-teams/.

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

GitHub

Autenticação por GitHub EE

Você precisa registrar um aplicativo OAuth no GitHub EE e, em seguida, informar ao Weblate todos as suas chaves secretas:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.github_enterprise.GithubEnterpriseOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITHUB_ENTERPRISE_KEY = "GitHub OAuth App Client ID"
SOCIAL_AUTH_GITHUB_ENTERPRISE_SECRET = "GitHub OAuth App Client Secret"
SOCIAL_AUTH_GITHUB_ENTERPRISE_URL = "https://git.example.com/"
SOCIAL_AUTH_GITHUB_ENTERPRISE_API_URL = "https://git.example.com/api/v3/"
SOCIAL_AUTH_GITHUB_ENTERPRISE_SCOPE = ["user:email"]

O aplicativo de autenticação do GitHub OAuth deve ser configurado para ter a URL de retorno como https://WEBLATE SERVER/accounts/complete/github-enterprise/.

Em vez do aplicativo GitHub OAuth, o aplicativo GitHub também pode ser usado. Com o aplicativo GitHub, as permissões podem ser concedidas em nível de repositório, organização e/ou usuário. Se você decidir usar o aplicativo GitHub, precisará habilitar a permissão Acesso: Somente leitura para Usuários - <Endereços de e-mail> e Organização - <Membros>.

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Backend classes

Autenticação por Bitbucket

Você precisa registrar um aplicativo no Bitbucket e, em seguida, dizer ao Weblate todos os seus segredos:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.bitbucket.BitbucketOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_BITBUCKET_OAUTH2_KEY = "Bitbucket Client ID"
SOCIAL_AUTH_BITBUCKET_OAUTH2_SECRET = "Bitbucket Client Secret"
SOCIAL_AUTH_BITBUCKET_OAUTH2_VERIFIED_EMAILS_ONLY = True

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Bitbucket

Google OAuth 2

To use Google OAuth 2, you need to register an OAuth application at <https://console.developers.google.com/>.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/google-oauth2/.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.google.GoogleOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GOOGLE_OAUTH2_KEY = "Client ID"
SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET = "Client secret"

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Google

OAuth 2 do Facebook

Como de costume com os serviços OAuth 2, você precisa registrar seu aplicativo no Facebook. Uma vez feito isso, você pode configurar o Weblate para usá-lo:

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/facebook/.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.facebook.FacebookOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_FACEBOOK_KEY = "key"
SOCIAL_AUTH_FACEBOOK_SECRET = "secret"
SOCIAL_AUTH_FACEBOOK_SCOPE = ["email", "public_profile"]

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Facebook

OAuth 2 do GitLab

Para usar o OAuth 2 do GitLab, você precisa registrar um aplicativo em <https://gitlab.com/profile/applications>.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/gitlab/ e garantir que você marque o escopo read_user.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.gitlab.GitLabOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITLAB_KEY = "Application ID"
SOCIAL_AUTH_GITLAB_SECRET = "Secret"
SOCIAL_AUTH_GITLAB_SCOPE = ["read_user"]

# If you are using your own GitLab
# SOCIAL_AUTH_GITLAB_API_URL = 'https://gitlab.example.com/'

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

GitLab

OAuth 2 do Gitea

Para usar o OAuth 2 do Gitea, você precisa registrar um aplicativo em https://SERVIDOR GITEA/user/settings/applications.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/gitea/.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.gitea.GiteaOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITEA_KEY = ""
SOCIAL_AUTH_GITEA_SECRET = ""

# If you are using your own Gitea
SOCIAL_AUTH_GITEA_API_URL = "https://gitea.example.com/"

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Nota

A configuração acima também funciona com o Forgejo; para um exemplo de implantação de produção com o Forgejo, consulte Codeberg Translate.

Ver também

Gitea

Microsoft Entra ID

Azure Active Directory (Azure AD) is now Microsoft Entra ID. Weblate keeps the azuread-oauth2 and azuread-tenant-oauth2 backend names for compatibility with the underlying Python Social Auth backends and existing deployments.

Weblate pode ser configurado para usar inquilinos comuns ou específicos para autenticação.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/azuread-oauth2/ para autenticação comum e https://SERVIDOR WEBLATE/accounts/complete/azuread-tenant-oauth2/ para autenticação específica do inquilino.

Você precisará do seguinte:

  • Application (client) ID is available on the app registration overview in the Microsoft Entra admin center. Object ID is not used in Weblate.

  • A ID do Diretório (locatário) é necessária para a autenticação com escopo de locatário, o que geralmente é desejado.

  • Secret value is displayed once you create a client secret for the app registration. Secret ID is not used in Weblate.

# Microsoft Entra ID common

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.azuread.AzureADOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# OAuth2 keys
SOCIAL_AUTH_AZUREAD_OAUTH2_KEY = ""
SOCIAL_AUTH_AZUREAD_OAUTH2_SECRET = ""
# Microsoft Entra ID with Tenant

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.azuread_tenant.AzureADTenantOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Application (client) ID
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_KEY = ""
# Secret value
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_SECRET = ""
# Directory (tenant) ID
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_TENANT_ID = ""

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Slack

Para usar o OAuth 2 do Slack, você precisa cadastrar um aplicativo em <https://api.slack.com/apps>.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/slack/.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.slack.SlackOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_SLACK_KEY = ""
SOCIAL_AUTH_SLACK_SECRET = ""

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Slack

Weblate OpenID Connect

Adicionado na versão 2026.11.

To sign in through Hosted Weblate or another Weblate installation, register a confidential authorization-code client with RSA SHA-256 signing on its OpenID Connect identity provider. Register this installation’s exact HTTPS callback URL, for example https://weblate.example.com/accounts/complete/weblate/.

Add the backend and client credentials to your settings:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.weblate.WeblateOpenIdConnect",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_WEBLATE_KEY = "Client ID"
SOCIAL_AUTH_WEBLATE_SECRET = "Client secret"

The default issuer is https://hosted.weblate.org/oidc. To authenticate against another installation, configure its issuer URL, including any deployment prefix:

SOCIAL_AUTH_WEBLATE_OIDC_ENDPOINT = "https://example.com/translations/oidc"

Do not append /.well-known/openid-configuration. The backend discovers the provider endpoints and requests the openid profile email scopes. Keep PKCE enabled; Weblate requires it.

The sign-in label is Hosted Weblate for Hosted Weblate and Weblate for other installations. Override the label or icon with SOCIAL_AUTH_WEBLATE_TITLE or SOCIAL_AUTH_WEBLATE_IMAGE.

Changing the issuer requires an explicit migration of existing account associations: the same subject identifier on different servers can refer to different people.

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Substituindo nomes e ícones de métodos de autenticação

Display names and bundled icons come from python-social-auth backend metadata. Weblate retains translated labels and local icons for its password and e-mail methods, and supplies its own fallback icon for providers without a logo. Add social_django.finders.SocialAuthIconFinder after the standard finders in STATICFILES_FINDERS to collect the provider icons from social-auth-core. The example and Docker settings include this finder. Run weblate collectstatic --noinput after upgrading.

You can override the authentication method display name and icon using settings as SOCIAL_AUTH_<NAME>_IMAGE and SOCIAL_AUTH_<NAME>_TITLE. For example overriding naming for Auth0 would look like:

SOCIAL_AUTH_AUTH0_IMAGE = "custom.svg"
SOCIAL_AUTH_AUTH0_TITLE = "Custom auth"

Relative image names retain the auth/ static directory convention. Existing bundled filenames, such as auth0.svg, also resolve to the shared social_auth/icons/ directory when no local override exists. Full HTTP URLs and data URLs continue to work.

Desativando autenticação por senha

Autenticação por e-mail e senha pode ser desativada através da remoção do social_core.backends.email.EmailAuth de AUTHENTICATION_BACKENDS. Mantenha sempre weblate.accounts.auth.WeblateUserBackend lá, ele é necessário para a funcionalidade central do Weblate.

Desabilitar a autenticação por e-mail desabilitará todas as funcionalidades relacionadas a e-mail – convite a usuários ou recurso de redefinição de senha.

Dica

Você ainda pode usar autenticação por senha para a interface administrativa, para usuários que você cria manualmente lá. Basta acessar /admin/login/.

Por exemplo, a autenticação usando apenas o provedor Open ID do openSUSE pode ser alcançada usando o seguinte:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.suse.OpenSUSEOpenId",
    "weblate.accounts.auth.WeblateUserBackend",
)

Autenticação por senha

O settings.py padrão vem com um conjunto razoável de AUTH_PASSWORD_VALIDATORS que garante que senhas fracas não sejam permitidas. Você pode personalizar essa configuração para corresponder à sua política de senha.

Além disso, você também pode instalar o django-zxcvbn-password-validator que fornece estimativas bastante realistas para dificuldade da senha e permite rejeitar senhas abaixo de um determinado limite.

OpenID Connect identity provider

Adicionado na versão 2026.11.

Weblate can act as an optional OpenID Connect (OIDC) identity provider for other applications. This is separate from signing in to Weblate using an external OIDC provider.

Install the oidc extra (uv pip install Weblate[oidc]). Generate a signing key and keep it outside version control:

openssl genrsa -out /path/to/oidc.key 4096

Enable OIDC_PROVIDER_ENABLED, add the optional applications, and configure OAUTH2_PROVIDER in your settings:

from pathlib import Path

OIDC_PROVIDER_ENABLED = True
INSTALLED_APPS += ["weblate.oidc", "oauth2_provider"]
OAUTH2_PROVIDER = {
    "OIDC_RSA_PRIVATE_KEY": Path("/path/to/oidc.key").read_text(encoding="utf-8"),
}

Run migrate before starting Weblate and its workers. Disabled installations do not need these applications, dependencies, or database tables. For Docker, see WEBLATE_OIDC_PROVIDER_ENABLED.

Register each client in Django administration under Applications. Select Authorization code and RSA with SHA-256. For clients supporting a secret, select Confidential and securely copy the generated client ID and secret. Secrets are hashed when saved. For clients without a secret, select Public; S256 PKCE is required for both client types. Register the client’s exact HTTPS callback URL. Only select Skip authorization for trusted clients; other clients require user consent before accessing identity information.

The issuer is the canonical Weblate site URL followed by /oidc, including any URL_PREFIX. The discovery URL is the issuer followed by /.well-known/openid-configuration. Configure clients to use this discovery URL, authorization code flow, S256 PKCE, and scopes openid profile email. Confidential-client authentication supports HTTP Basic or a form-encoded client secret. For Zammad, register a public client, set its issuer to the Weblate issuer URL, select sub as the UID field, request openid profile email, and enable PKCE. Its callback is https://zammad.example.com/auth/openid_connect/callback. Nextcloud’s user_oidc app can use a confidential client with the discovery URL. Shared logout and automatic client registration are not provided.

Authorization requests can use GET or form-encoded POST. Clients exchange tokens and fetch UserInfo through their servers.

Clients can request fresh authentication using prompt=login or limit the age of the existing authentication using max_age in seconds. The limit also applies when submitting consent. max_age=0 always requires a new login. With prompt=none, Weblate returns login_required or consent_required when authentication or consent needs user interaction.

Federated sign-in can reuse an upstream session without revealing its authentication time. These sign-ins omit auth_time from ID tokens and cannot satisfy prompt=login or max_age requests; Weblate returns login_required instead. Use a password-based sign-in or e-mail verification when fresh authentication is required. A failed freshness request does not prevent later ordinary federated sign-ins.

The sub claim is the Weblate user ID as a string, stable across username and e-mail changes. The profile scope adds preferred_username, name, and family_name; both name claims contain Weblate’s full name. The email scope adds email and email_verified. Verification is reported only when the current address has a recorded verification. Claims are available in ID tokens and from /oidc/userinfo/ using an access token.

When Legal module is installed, clients can additionally request the optional weblate:legal scope. It adds weblate_tos_version to ID tokens and UserInfo, containing the version the user actually accepted as an ISO date, for example "2026-09-01". Older accepted versions are returned unchanged; the claim is omitted when no acceptance is recorded. Reading it does not record consent or expose the acceptance timestamp, IP address, or user agent. Without the legal module, this scope is unavailable.

Receiving servers using the same legal package, such as wllegal, can use this date to match their legal version. They must explicitly trust the issuer and match the accepted version to their own documents before suppressing local confirmation. This provider only exposes the information; accepting shared consent on receiving Weblate servers requires separate integration.

New browser sessions created for OIDC sign-in expire after 60 seconds, including when sign-in requires Autenticação de dois fatores. Existing browser sessions keep their expiry policy. Sessions created before the provider recorded an authentication time require a fresh sign-in before authorizing a client. If the browser session expires while the consent page is open, submitting the form restarts sign-in and displays a new consent page. The earlier approval or denial is discarded; the user must submit the new form. Concurrent authorization attempts are tracked separately. Pending attempts expire after 15 minutes; starting more than 16 discards the oldest attempt.

Access and ID tokens last one hour. Refresh tokens rotate on use and expire after 30 days of inactivity beyond their associated access token’s expiry. ID tokens retain the original authentication time across refreshes, including its absence for federated sign-ins, even when the user signs in again elsewhere. Reusing an already rotated refresh token revokes its token family. Tokens work independently of the browser session and do not authorize Weblate REST API access. Account removal deletes provider credentials, and inactive accounts cannot authorize or use provider tokens. Celery periodically cleans expired credentials.

To rotate signing keys, replace OIDC_RSA_PRIVATE_KEY and retain old private keys in OIDC_RSA_PRIVATE_KEYS_INACTIVE until outstanding ID tokens and cached key sets have expired. Only public key material is published by JWKS.

When migrating a client from SAML, explicitly map its existing identities to the OIDC issuer and subject. Do not assume SAML NameIDs equal OIDC subjects, or link accounts solely by matching e-mail addresses. For weblate.org, existing accounts are linked by persistent SAML provider/identity pairs; its client integration and identity mapping require a separate migration.

Autenticação por SAML

Adicionado na versão 4.1.1.

Alterado na versão 5.12: As dependências para autenticação SAML não estão mais incluídas nos extras padrão all. Você precisa incluir saml ao instalar o pacote Weblate usando pip (uv pip install Weblate[all,saml]).

Siga as instruções do Python Social Auth para configuração. Diferenças notáveis:

  • Weblate tem suporte a único IDP que tem de ser chamado de weblate em SOCIAL_AUTH_SAML_ENABLED_IDPS.

  • The SAML XML metadata URL is /accounts/metadata/saml/, which is also an entity ID.

  • The sign-in URL is /accounts/complete/saml/ (also known as ACS URL).

  • As configurações a seguir são preenchidas automaticamente: SOCIAL_AUTH_SAML_SP_ENTITY_ID, SOCIAL_AUTH_SAML_TECHNICAL_CONTACT, SOCIAL_AUTH_SAML_SUPPORT_CONTACT

Exemplo de configuração:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.email.EmailAuth",
    "social_core.backends.saml.SAMLAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_SAML_SP_ENTITY_ID = f"https://{SITE_DOMAIN}/accounts/metadata/saml/"
SOCIAL_AUTH_SAML_SP_PUBLIC_CERT = "-----BEGIN CERTIFICATE-----"
SOCIAL_AUTH_SAML_SP_PRIVATE_KEY = "-----BEGIN PRIVATE KEY-----"
SOCIAL_AUTH_SAML_ENABLED_IDPS = {
    "weblate": {
        "entity_id": "https://idp.testshib.org/idp/shibboleth",
        "url": "https://idp.testshib.org/idp/profile/SAML2/Redirect/SSO",
        "x509cert": "MIIEDjCCAvagAwIBAgIBADA ... 8Bbnl+ev0peYzxFyF5sQA==",
    }
}
SOCIAL_AUTH_SAML_ORG_INFO = {
    "en-US": {
        "name": "example",
        "displayname": "Example Inc.",
        "url": "http://example.com"
    }
}
SOCIAL_AUTH_SAML_TECHNICAL_CONTACT = {
    "givenName": "Tech Gal",
    "emailAddress": "technical@example.com"
}
SOCIAL_AUTH_SAML_SUPPORT_CONTACT = {
    "givenName": "Support Guy",
    "emailAddress": "support@example.com"
}

You can generate a new pair of keys using:

openssl req -newkey rsa:4096 -new -x509 -days 3652 -nodes -out saml.crt -keyout saml.key

The default configuration extracts user details from following attributes, configure your IdP to provide them:

Atributo

Referência de URI SAML

Nome completo

urn:oid:2.5.4.3

Primeiro nome

urn:oid:2.5.4.42

Sobrenome

urn:oid:2.5.4.4

E-mail

urn:oid:0.9.2342.19200300.100.1.3

Usuário

urn:oid:0.9.2342.19200300.100.1.1

When configuring Weblate SP in your IdP, it is recommended to choose persistent Name ID format.

Dica

Some identity providers (such as Microsoft Entra ID with multi-factor authentication) require disabling the default requestedAuthnContext in the SAML security configuration:

SOCIAL_AUTH_SAML_SECURITY_CONFIG = {"requestedAuthnContext": False}

In Docker, set WEBLATE_SAML_SECURITY_CONFIG instead.

Dica

The example above and the Docker image define an IdP called weblate. You might need to configure this string as Relay in your IdP.

Nota

Weblate authentication relies on the RelayState parameter to be passed through the authentication process. This needs to be configured with some identity providers:

Autenticação por LDAP

A autenticação por LDAP pode ser melhor alcançada utilizando o pacote django-auth-ldap. Você pode instalá-lo através dos meios habituais:

# Using PyPI
uv pip install 'django-auth-ldap>=1.3.0'

# Using apt-get
apt-get install python-django-auth-ldap

Dica

Este pacote está incluído no contêiner Docker, consulte Instalando usando Docker.

Nota

Há algumas incompatibilidades no módulo Python LDAP 3.1.0, o que pode impedir você de usar essa versão. Se você obter o erro AttributeError: ‘module’ object has no attribute ‘_trace_level’, fazer o downgrade para python-ldap 3.0.0 pode ajudar.

Uma vez que você tenha o pacote instalado, você pode conectá-lo à autenticação do Django:

# Add LDAP backed, keep Django one if you want to be able to sign in
# even without LDAP for admin account
AUTHENTICATION_BACKENDS = (
    "django_auth_ldap.backend.LDAPBackend",
    "weblate.accounts.auth.WeblateUserBackend",
)

# LDAP server address
AUTH_LDAP_SERVER_URI = "ldaps://ldap.example.net"

# DN to use for authentication
AUTH_LDAP_USER_DN_TEMPLATE = "cn=%(user)s,o=Example"
# Depending on your LDAP server, you might use a different DN
# like:
# AUTH_LDAP_USER_DN_TEMPLATE = 'ou=users,dc=example,dc=com'

# List of attributes to import from LDAP upon sign in
# Weblate stores full name of the user in the full_name attribute
AUTH_LDAP_USER_ATTR_MAP = {
    "full_name": "name",
    # Use the following if your LDAP server does not have full name
    # Weblate will merge them later
    # 'first_name': 'givenName',
    # 'last_name': 'sn',
    # Email is required for Weblate (used in VCS commits)
    "email": "mail",
}
# Optional: route "Forgot your password?" to your LDAP self-service page
PASSWORD_RESET_URL = "https://id.example.net/password-reset/"


# Hide the registration form
REGISTRATION_OPEN = False

Nota

Você deve remover 'social_core.backends.email.EmailAuth' da configuração AUTHENTICATION_BACKENDS; caso contrário, os usuários poderão definir sua senha no Weblate e autenticar usando isso. Manter 'weblate.accounts.auth.WeblateUserBackend' ainda é necessário para fazer permissões e facilitar usuários anônimos. Ele também permitirá que você faça login usando uma conta administrativa local, se você a criou (por exemplo, usando createadmin).

Usando senha associada

Se não for possível usar a associação direta para autenticação, será necessário usar a busca e fornecer um usuário para associar à busca. Por exemplo:

import ldap
from django_auth_ldap.config import LDAPSearch

AUTH_LDAP_BIND_DN = ""
AUTH_LDAP_BIND_PASSWORD = ""
AUTH_LDAP_USER_SEARCH = LDAPSearch(
    "ou=users,dc=example,dc=com", ldap.SCOPE_SUBTREE, "(uid=%(user)s)"
)

Integração com Active Directory

import ldap
from django_auth_ldap.config import LDAPSearch, NestedActiveDirectoryGroupType

AUTH_LDAP_BIND_DN = "CN=ldap,CN=Users,DC=example,DC=com"
AUTH_LDAP_BIND_PASSWORD = "password"

# User and group search objects and types
AUTH_LDAP_USER_SEARCH = LDAPSearch(
    "CN=Users,DC=example,DC=com", ldap.SCOPE_SUBTREE, "(sAMAccountName=%(user)s)"
)

# Make selected group a superuser in Weblate
AUTH_LDAP_USER_FLAGS_BY_GROUP = {
    # is_superuser means user has all permissions
    "is_superuser": "CN=weblate_AdminUsers,OU=Groups,DC=example,DC=com",
}

# Map groups from AD to Weblate
AUTH_LDAP_GROUP_SEARCH = LDAPSearch(
    "OU=Groups,DC=example,DC=com", ldap.SCOPE_SUBTREE, "(objectClass=group)"
)
AUTH_LDAP_GROUP_TYPE = NestedActiveDirectoryGroupType()
AUTH_LDAP_FIND_GROUP_PERMS = True

# Optionally enable group mirroring from LDAP to Weblate
# AUTH_LDAP_MIRROR_GROUPS = True

Autenticação por CAS

Autenticação por CAS pode ser obtida usando um pacote como o Django CAS NG.

O primeiro passo é divulgar o campo de e-mail do usuário via CAS. Isso tem que ser configurado no próprio servidor CAS, e requer que você execute pelo menos CAS v2, já que o CAS v1 não tem suporte a atributos.

O segundo passo é atualizar o Weblate para utilizar o seu servidor CAS e os seus atributos.

Para instalar Django CAS NG:

uv pip install django-cas-ng

Uma vez que o pacote instalado, você pode conectá-lo ao sistema de autenticação do Django modificando o arquivo settings.py:

# Add CAS backed, keep the Django one if you want to be able to sign in
# even without LDAP for the admin account
AUTHENTICATION_BACKENDS = (
    "django_cas_ng.backends.CASBackend",
    "weblate.accounts.auth.WeblateUserBackend",
)

# CAS server address
CAS_SERVER_URL = "https://cas.example.net/cas/"

# Add django_cas_ng somewhere in the list of INSTALLED_APPS
INSTALLED_APPS = (..., "django_cas_ng")

Finalmente, um sinal pode ser usado para mapear o campo de e-mail para o objeto do usuário. Para que isso funcione, você tem que importar o sinal do pacote django-cas-ng e conectar seu código com este sinal. Fazer isso em configurações de arquivo pode causar problemas, portanto, é sugerido colocá-lo:

from django_cas_ng.signals import cas_user_authenticated
from django.dispatch import receiver


@receiver(cas_user_authenticated)
def update_user_email_address(sender, user=None, attributes=None, **kwargs):
    # If your CAS server does not always include the email attribute
    # you can wrap the next two lines of code in a try/catch block.
    user.email = attributes["email"]
    user.save()

Configurando autenticação por Django de terceiros

Geralmente, qualquer plugin de autenticação Django deve funcionar com Weblate. Basta seguir as instruções do plugin, lembrando de manter o backend do usuário Weblate instalado.

Normalmente, a instalação consiste em adicionar uma autenticação de backend a AUTHENTICATION_BACKENDS e a instalar um aplicativo de autenticação (se houver) no INSTALLED_APPS:

AUTHENTICATION_BACKENDS = (
    # Add authentication backend here
    "weblate.accounts.auth.WeblateUserBackend",
)

INSTALLED_APPS += (
    # Install authentication app here
)

Autenticação de dois fatores

Adicionado na versão 5.7.

Dica

Autenticação de dois fatores adiciona outra camada de segurança à sua conta, exigindo mais do que apenas uma senha para obter acesso.

Weblate é compatível com os seguintes fatores secundários:

Chaves de segurança (WebAuthn)

Há suporte para chaves de acesso e chaves de segurança.

Os Passkeys validam sua identidade usando toque, reconhecimento facial, uma senha de dispositivo ou um PIN, pois incluem a verificação do usuário.

As chaves de segurança são credenciais do WebAuthn que só podem ser usadas como um segundo fator de autenticação e que validam apenas a presença do usuário.

When signing in on a new computer or in a different browser, your passkey might not be available. Use a device where the passkey is available, or connect your registered security key. A verification error can mean that the request timed out, was canceled, or that the credential is unavailable; it does not identify the exact cause.

You can also select another configured verification method on the sign-in page, such as Use recovery codes. If you cannot use any configured method, contact the site administrator for help.

Aplicativos de autenticação (TOTP)

Aplicativos autenticadores e complementos de navegador como Aegis, Bitwarden, Google Authenticator, 1Password, Authy, Microsoft Authenticator etc. geram senhas de uso único baseadas em tempo que são usadas como um segundo fator para verificar sua identidade quando solicitado durante o login.

Registration becomes active only after you verify a code from the app. Complete registration within 10 minutes of confirming your sign-in method; otherwise confirm it again and use the new QR code. Each registration can be completed only once. After registering, wait for the next code before using the app to sign in.

Only one registration can be pending per account. Confirming your sign-in method in another browser session invalidates the pending QR code and starts a new registration.

If you have more than one registered authenticator app, select the app you are using when entering its code during sign-in.

Códigos de recuperação

Os códigos de recuperação podem ser usados para acessar sua conta caso você perca o acesso ao seu dispositivo e não consiga receber os códigos de autenticação em duas etapas.

Mantenha seus códigos de recuperação tão seguros quanto sua senha. Recomendamos salvá-los com um gerenciador de senhas como Bitwarden, 1Password, Authy ou Keeper.

Each user can configure this in Segurança and second factor will be required to sign in addition to the existing authentication method.

Before registering the first authenticator app or security key, confirm your existing sign-in method. Enter your current password, including one verified by a configured Django authentication backend such as LDAP, or sign in again through an already connected provider. If neither method is available, contact an administrator to recover access. Registering a new factor does not count as a recent second-factor verification for other sensitive actions, such as creating a project token; complete a separate second-factor challenge for those actions.

Viewing the personal API key and changing credentials, access permissions, or account status requires credential verification from the last 10 minutes in a browser session. This includes managing project members and tokens, teams, roles, user accounts, and project and component visibility. Weblate prompts for a second factor when one is configured. Otherwise, enter your current password, verify through a configured Django authentication backend, or sign in again through an already connected provider. Account deletion still requires confirmation through a link sent to your e-mail address. API token requests continue to use token authentication.

This can be enforced for users at the project (see Autenticação de dois fatores obrigatória) or team level. In site-wide deployments, this can also be used to enforce two-factor authentication for all users by enabling it on the default Users team, which is assigned automatically to new users by automatic team assignment.

As permissões de uma equipe com autenticação de dois fatores aplicada não serão aplicadas a usuários que não a tenham configurado.