Skip to main content
A person using Gecko has exactly two identities:
  1. Sign-in identity: how you prove who you are. Email and password, GitHub, or your company’s SSO.
  2. In-app identity: who you are once signed in. Your Gecko user, a member of a team, with a role and a linked GitLab account.

Sign-in identity

How you get in, and nothing more. Gecko accepts these methods:
  • Email and password
  • GitHub sign-in
  • Company SSO (SAML or OIDC), started from your team’s sign-in URL
They all land you in the same Gecko user. Once your team switches SSO enforcement to Required, only the SSO method is accepted; sessions from the other two are blocked. A sign-in method carries no permissions. Signing in with GitHub doesn’t show Gecko your repositories, and a SAML assertion doesn’t grant access to anything; at most, IdP groups map to a role.

In-app identity

Your Gecko user is where permissions actually live, on two axes: Your Gecko user can have several sign-in methods linked to it, so your in-app identity (membership, role, audit history) stays the same while your sign-in options change. Settings > General > Personal connections lists each connected method with its email, and offers: Your profile email can be set to the email of any connected sign-in method.

How sign-in linking works

Linking is an OAuth 2.0 / OIDC authentication through Gecko’s auth service (Auth0), not an API authorization. Linking GitHub proves you own the GitHub account and nothing more: Gecko receives an identity claim, not an access token with repository scope, and it never sees your password for any method. The flow is deliberately strict:
  • Fresh authentication is required (prompt=login): an existing browser session with the target method is not accepted.
  • The intent is single-use and expires in 10 minutes, and it’s bound to the session that started it with a cookie, so a link can’t be initiated on one machine and completed on another.
  • Conflicts never merge silently. If the identity you authenticated with already belongs to another Gecko profile, the link stops and you’re offered the explicit account-merge flow instead.

Linking to a team directory

When your admin assigns you in the team’s identity provider and you already have a Gecko account, nothing happens to that account on its own. Gecko doesn’t email you, and it doesn’t verify who owns your email domain. The admin sees you as waiting to link and asks you to sign in to Gecko from the IdP tile. You then sign in through your company’s connection and sign in to your existing account. Both must happen within 10 minutes. Gecko shows a link screen that names the team and connection and says what linking grants:
  • It grants the team membership and role your directory assigns, and lets anyone who administers that connection sign in to this account.
  • You keep the account, its history, its other teams, and any sign-in method you already verified.
  • If Gecko can’t confirm your mailbox, it emails a one-time code to the directory address and asks for it. After you link, it deletes the unverified sign-in methods on the account and emails you.
  • Deprovisioning removes your team membership and the sign-in methods that connection created. Your account and other teams stay.

GitLab account linking

You link your own GitLab account to your Gecko user from Settings > General > Personal connections by clicking Connect next to GitLab. Linking identifies you to Gecko; whether it also limits what you see depends on your team’s repository access setting:
  • Enforced: an admin turned on Settings > Members > Enforce GitHub/GitLab permissions. You see a repository only if the team connection synced it and your own account can push to it. Until you link, no repositories appear. ZIP uploads are turned off while enforcement is on.
  • Not enforced (the default): every member sees every synced repository, and linking only attributes your activity to you.
The admin who turns enforcement on must link their own account first, so they keep access. GitHub accounts work the same way: sign in with GitHub, or click Connect next to GitHub. The link is a standard OAuth 2.0 authorization-code flow against your GitLab instance, with a read-only scope: What it does and doesn’t do:
  • Read-only. The read_api scope can’t write anything. Scanning, MR comments, and fix MRs stay on the team’s service account PAT, which this flow never touches. Gecko never acts as you in GitLab.
  • Self-managed instances need one admin step first: registering an OAuth application on the instance (Gecko can’t pre-register one on your server) and entering its Application ID and Secret in Gecko. See Enable user linking.
  • Revocable from both sides. Unlink in Gecko, or revoke the authorization from your GitLab profile’s applications settings. If your team enforces repository permissions, your dashboard visibility is gone until you link again.

Connected accounts

Personal connections also lists your connected accounts: your identities on GitHub, GitLab, Slack, Linear, and Jira. These are about attribution (showing the right name and avatar next to your commits, PRs, and tickets), not access. Each row shows the provider, your handle and avatar, and a status: GitLab identities are tracked per instance: an account on your self-managed GitLab is a distinct identity from an account with the same user ID on GitLab.com or another instance, so identities from different instances can never collide.

FAQ

Yes. Turn on Settings > Members > Enforce GitHub/GitLab permissions. Each user then sees only the synced repositories their own account can push to, so your GitHub or GitLab permissions are the single source of truth. To narrow what exists in Gecko at all, scope the team connection itself.
If your team enforces repository permissions, either you haven’t linked your account yet, or your account can’t push to any repository the team connection syncs. If the whole team sees nothing, the connection itself isn’t set up.
Unassign them from the Gecko app in your IdP (stops sign-in) and remove them from Settings > Members, which removes their linked accounts with them. The team’s source-control connection is unaffected; surviving offboarding is exactly why it runs on a service account, not on an employee’s credentials.
Everything Gecko writes to your Git provider (MR comments, fix branches, fix MRs) runs on the team’s connection, so GitLab attributes it to the service account. Your linked GitLab account is read-only and only shapes what you see. Actions inside the Gecko dashboard are logged against your Gecko user in the audit log.