Account
Team
The two kinds of people, company members and project editors or viewers, what each is checked against, and direct access and expiring invitation links.

Two kinds of people
Every project belongs to one company, and the company holds the plan, the billing and the people who run it. Someone can reach a project in one of two ways, and the two are different in kind, not just in degree:
- Company members open every project in the company with full control.
They create projects, manage billing, and invite and remove people. There
is one company role, with no admin or member split inside it: every
member can do everything below (
api/dependencies.py#get_company_for_member,#get_user_role_in_project). - Project editors and viewers see only the projects shared with them,
one project at a time. An editor can change that project's data; a viewer
reads it. Neither ever sees the company's billing, its Members page or its
other projects, and neither can invite anyone. A project row can hold only
those two roles, enforced by a database check constraint on
project_members.role(alembic/versions/b5e1f7c3a9d2_companies.py#PROJECT_MEMBER_ROLE_CHECK).
The plan and its limits belong to the company, not to whoever is looking at a screen; see Plans and limits for what that means for prompt slots, projects and billing.
Internally a company member's role on any of the company's projects is the
string owner: every project payload carries my_role, and it reads
owner for a member of the project's company and the row's own role for
anyone else (api/schemas/project.py#my_role,
api/routers/projects.py#_with_my_role,
api/dependencies.py#get_user_role_in_project). The app never shows that
word for a person: it labels the three values Company member, Editor and
Viewer (frontend/src/lib/permissions.js#roleLabel).
What each can do
What each kind of person can actually do, read from the checks themselves rather than from what the names suggest:
| Capability | Company member | Editor | Viewer | Checked by |
|---|---|---|---|---|
| Read this project's data (Overview, prompts, competitors, citations, articles, optimizations, alerts, integrations, keywords, tags) | Yes | Yes | Yes | A member of the project's company, or an active project row of either role (api/dependencies.py#get_project_for_user) |
| Create, edit or delete that data, or start any run a person can trigger, outside the company-member rows below | Yes | Yes | No | Same check, plus a role read that rejects only viewer (api/dependencies.py#require_write_access) |
| See the project's team list | Yes | Yes | Yes | Anyone who can open the project (api/routers/team.py#list_members) |
| Add a person to the project, change their role, or take their access away | Yes | No | No | api/routers/team.py#invite_member, #update_member, #remove_member |
| Edit and save the project record, or archive the project | Yes | No | No | api/routers/projects.py#update_project, #delete_project |
| Add or remove one of the project's own social accounts | Yes | No | No | api/routers/growth_advisor.py#add_social_profile, #delete_social_profile |
| Open the company's Billing, Members, Projects and General pages, or create a project in the company | Yes | No | No | api/dependencies.py#get_company_for_member, api/services/company_projects.py#resolve_target_company |
| Download this project's exports, CSV or JSON | Yes | Yes | Yes | Gated by the company's plan, not by role; see Plans and limits |
Reading is get_project_for_user: it accepts a member of the project's
company and anyone holding an active project row, whatever its role, so a
viewer opens the same screens an editor does. What a viewer sees on those
screens is not identical, though: the app reads my_role to disable, rather
than hide, any control a viewer's role would fail on, with one line saying
why (frontend/src/lib/permissions.js#canWrite,
frontend/src/lib/components/RoleNotice.svelte). Writing narrows that to
require_write_access, which calls the same membership check and then
rejects the request only if the caller's role reads viewer. That second
check guards the write routes across the product, from prompts and
competitors to alerts, articles, Explorer and the advisors, which is why
the write row states a rule rather than a list. Running a prompt on demand
and asking for more prompt suggestions are both behind it
(api/routers/executions.py#execute_single_query, #execute_batch,
api/routers/prompt_candidates.py#generate_more_candidates).
On the project rows where the matrix says "No" for the editor, the check is
a third, separate one: the endpoint reads the caller's role and accepts
nothing but owner. Since a project row can only hold editor or viewer, that third
check passes for company members and for no one else. It covers the
project's people and invitations, saving or archiving the project record,
and the two social-account endpoints. The company pages use a fourth check
of their own, get_company_for_member, which answers "not found" to anyone
who is not a member of that company, an editor or viewer of one of its
projects included, so a company's id reveals nothing to them.
Company members
A company's members are listed on its Members page,
/companies/<id>/members, which only its members can open
(api/routers/companies.py#list_company_members). From there a member can:
- Invite someone by link, covered below. Accepting an invitation link is the only way anyone joins a company, whether or not they already have an account: there is no way to add an existing account to a company directly.
- Remove another member. You cannot remove yourself from this page.
To leave a company yourself, use Leave beside it under Your companies
on Your profile.
The last member can neither leave nor be removed, because a company needs at
least one, so while you are its last member Leave is disabled and shows
the reason (api/routers/companies.py#remove_company_member, #leave_company).
Joining a company supersedes any project access the person already had in
that company: accepting the invitation deletes their editor or viewer rows
on its projects in the same step, since they now open every project anyway.
Rows on another company's projects are untouched
(api/services/team_invitations.py#accept,
api/services/companies.py#add_company_member).
The Members page also lists the company's project-only people under Invited to one project: each editor or viewer, the project they were invited to, and a link to that project's Team page, where their access is managed.
Project editors and viewers
Team, under Project settings, shows two lists. The first, headed
"From" and the company's name, lists the company's members, who can open
every project in it, by name and email; anyone who can open the project
sees this list, editors and viewers included. The second list holds the people invited to this project only,
the editors and viewers, active or paused (api/routers/team.py#list_members).
Only company members can change anything here, and they also get a link to
the company's Members page.
Adding someone to a project offers two roles, Editor and Viewer
(api/schemas/team.py#MemberInvite). Add member grants immediate access
to an existing account without an acceptance step; an address with no
account is refused, so use an invitation link instead. Re-adding a paused
person restores their access with the role you pick. A company member's
address is refused too: they can already open every project in the company
(api/routers/team.py#invite_member).
"Removing" someone from a project is the same operation as pausing them,
one layer down: the row's active flag goes off and nothing is deleted, so
the row keeps its role and switching it back on restores it
(api/routers/team.py#remove_member, #update_member).
An editor or viewer can leave a project on their own, from Your companies
on Your profile, where each
project shared with them reads "Invited to" that project with its role and
a Leave button. Leaving turns their own row off. A company member cannot
leave a single project this way; they leave the company instead
(api/routers/team.py#leave_project).
Invite someone by link
There are two kinds of invitation, and only company members can create, see or revoke either:
- To the company, from its Members page. Accepting makes the person a
company member, and it is the only way to become one
(
api/services/team_invitations.py#create_company_invitation). - To one project, from that project's Team page, as an Editor or a
Viewer (
api/services/team_invitations.py#create).
An invitation's role is held in its own column, which accepts member only
on a company invitation and editor or viewer only on a project one
(alembic/versions/b5e1f7c3a9d2_companies.py#INVITATION_ROLE_CHECK).
Inviting someone who already has access is refused, and a company member
already has access to every project in the company, so their address is
refused on a project invitation too. So is a second pending invitation to
the same address: revoke the first before creating another
(api/services/team_invitations.py#create, #create_company_invitation).
Create invitation link displays the full link once. Copy it and share it
with that person; the platform does not send an invitation email. The link
expires after seven days. The recipient opens it, selects Continue to
invitation, signs in with the exact invited address, reviews what they
are joining (a company, or a project and its role), and explicitly accepts.
Both Google sign-in and email links return to this review before
onboarding. Normal sign-in policies still apply, including the Google
free-email exception (api/services/team_invitations.py#accept).
Seats are unlimited on every plan, so no invitation reserves a seat or waits
for one. What is checked, when the link is opened and again when it is
accepted, is that the invitation can still be honoured: a project
invitation's project must still be active, the company must still be
active, and the person who created the link must still be an active member
of that company (api/services/team_invitations.py#eligible). A company
counts as active while at least one of its members is an active user
(api/services/companies.py#company_active).
Revoke a pending invitation from Issued invitations; Revoke asks
first ("Revoke this invitation?"), and Keep it cancels. Accepted
invitations are managed through the person's access controls instead, and
an invitation cannot change the role of someone who already has active
access. Revoked or expired links grant no access. A project can have 50
pending invitations, and a company the same number of its own; the list
shows pending links first, then recent history
(api/services/team_invitations.py#revoke, #revoke_company_invitation).

No seat limit
Every plan admits as many people as you like, both company members and
project editors and viewers. The plan column that once capped team members
holds the "no limit" value on every plan, and no check counts people when
someone is added, invited or accepted
(alembic/versions/b5e1f7c3a9d2_companies.py#UNLIMITED_SEATS_SQL,
api/services/seed.py#DEFAULT_PLANS). The Billing page has no seat meter.
Getting into a project you were added to
Everything above is enforced the moment a request carries a project's id.
What decides whether that id ever reaches your browser is a different call.
The project switcher, and the redirect that sends a signed-in person who
can open no project to onboarding, both come from GET /projects
(api/routers/projects.py#list_projects,
frontend/src/routes/(app)/+layout.server.js#currentProject).
That endpoint returns a project on either of two grounds: it belongs to a
company you are a member of, or you hold an active row on it
(api/routers/projects.py#_accessible_to, api/services/companies.py#member_company_ids).
That is the same definition of access get_project_for_user applies when a
request names one project, so the list a person can see and the projects
their requests are allowed to reach are the same set. The switcher groups
the list by company, company you are a member of first
(frontend/src/lib/company.js#groupProjectsByCompany), and loading one
project's own record runs through that same clause
(api/routers/projects.py#_load_project_with_countries, used by
#get_project), so an editor or viewer can open the project's settings
screen too.
Two things follow from that. Pausing someone's project row takes the project back out of their switcher at the same moment it takes away their access, because the list and the per-request check read the same active flag. And nothing about this widens what an editor or viewer can do: the company-member rows in the matrix above are checked exactly as described, so reaching a screen is not the same as being allowed to write from it.
From the old project roles
Before companies, every project had owners, editors and viewers, and the
plan belonged to the person who created the project. The move kept
everyone's access and gave nobody more than they could already reach.
Each project creator got a company of their own, holding their projects
and their plan, with themselves as a member
(alembic/versions/b5e1f7c3a9d2_companies.py#ADD_CREATOR_MEMBERS_SQL,
#LINK_PROJECTS_SQL). Anyone else who was an active owner on every project
of that creator, archived ones included, became a member of the same
company; any other owner row stayed on its project as an editor row
(alembic/versions/b5e1f7c3a9d2_companies.py#PROMOTE_FULL_OWNERS_SQL,
#DEMOTE_REMAINING_OWNERS_SQL). Every project invitation that named the
owner role, pending or not, now names the editor role
(alembic/versions/b5e1f7c3a9d2_companies.py#OWNER_INVITATIONS_SQL).
Related
- Plans and limits: what the company's plan covers, where Billing lives, and why exports ignore role entirely
- Projects: who can open and save the project record itself, and what pausing or archiving a project does
- Create your account: how sign-in works for the person you are about to add, and the companies on Your profile
Last verified 2026-10-14