giantcontext 1.26.0

Official Python SDK for the GiantContext API

GiantContext Python SDK

Official Python SDK for the Giant Context API -- a headless CMS and AI content platform.

Installation

pip install giantcontext

poetry add giantcontext

uv add giantcontext

Usage

import asyncio
import os
from giantcontext import create_giant_context

async def main():
    async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
        # Get current user
        me = await gc.me.get_me()
        print(f"Logged in as {me['displayName']}")

        # List organizations you belong to
        orgs = await gc.me.get_my_organizations()
        org = orgs[0]

        # List projects in the organization
        projects = await gc.projects.get_projects(id=org["id"])
        for project in projects["data"]:
            print(f"  {project['name']} ({project['slug']})")

        # Discover apps in a project
        apps = await gc.project_apps.get_project_apps(
            id=org["id"],
            project_id=projects["data"][0]["id"],
        )
        for app in apps["data"]:
            print(f"  {app['type']}: {app['name']}")

asyncio.run(main())

Authentication

API Keys

API keys use the gct_ prefix. Create one from the Giant Context console under Settings > API Keys.

gc = create_giant_context(api_key="gct_a1b2c3d4e5f6...")

The recommended pattern is to store your key in an environment variable:

export GIANTCONTEXT_API_KEY="gct_a1b2c3d4e5f6..."

import os
from giantcontext import create_giant_context

gc = create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"])

Token Exchange

The SDK never sends your API key directly to resource endpoints. On the first request, it exchanges the key for a short-lived JWT via POST /api/auth/token. The JWT is cached in memory and automatically refreshed 60 seconds before expiry. This is handled transparently -- you never need to manage tokens yourself.

Core Concepts

Giant Context organizes content in a hierarchy:

Organization
  └── Project
        ├── Apps
        │     ├── Website  (pages, posts, headers, footers, templates, dialogs, sidebars)
        │     ├── Email    (emails, campaigns, segments, headers, footers)
        │     ├── CRM      (contacts, companies, activities)
        │     ├── Forms    (forms, submissions)
        │     └── KB       (articles, categories)
        ├── Files          (images, documents, folders)
        ├── Branding       (colors, fonts, logos, design briefs)
        ├── Drafts         (AI-generated content awaiting review)
        └── Ideas          (AI suggestions from Mind)

Organizations contain one or more Projects. Each project has Apps (website, email, CRM, forms, knowledge base), plus shared resources like files and branding. Drafts are AI-generated content items, and Ideas are suggestions surfaced by Mind, the AI engine.

The SDK mirrors this hierarchy with resource namespaces:

gc.organizations       # Organization-level operations
gc.projects            # Project CRUD and lookup
gc.project_apps        # App discovery within a project
gc.website             # Website pages, posts, headers, footers, templates
gc.email               # Email templates, campaigns, segments
gc.crm                 # Contacts, companies, activities
gc.forms               # Forms and submissions
gc.other               # Knowledge base articles and categories
gc.project_files       # File management and search
gc.project_branding    # Branding assets
gc.drafts              # AI-generated drafts
gc.ideas               # Mind suggestions
gc.me                  # Current user profile, notifications, activity

Async Context Manager

The SDK is fully async, built on httpx. The recommended pattern is async with, which ensures the underlying HTTP connection pool is properly closed:

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    orgs = await gc.me.get_my_organizations()
    # Connection pool is closed automatically on exit

If you need manual lifecycle control:

gc = create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"])
try:
    orgs = await gc.me.get_my_organizations()
finally:
    await gc.close()

Working with Organizations and Projects

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    # List organizations the current user belongs to
    orgs = await gc.me.get_my_organizations()
    org_id = orgs[0]["id"]  # e.g. "d4e5f6a7-1234-5678-9abc-def012345678"

    # Get a specific organization by ID
    org = await gc.organizations.get_organization(id=org_id)
    print(org["name"])  # "Acme Corp"

    # Or look it up by slug
    org = await gc.organizations.get_organization_by_slug(slug="acme-corp")

    # List projects in the organization
    projects = await gc.projects.get_projects(id=org_id)
    # projects == {"data": [...], "pagination": {"page": 1, "pageSize": 25, "total": 3}}

    # Get a specific project by ID
    project = await gc.projects.get_project(
        id=org_id,
        project_id="a1b2c3d4-5678-9abc-def0-123456789abc",
    )
    print(project["name"])  # "Marketing Site"

    # Or look it up by slug
    project = await gc.projects.get_project_by_slug(
        id=org_id,
        project_slug="marketing-site",
    )

Working with Website Content

Most app-level resources require three IDs: organization_id, project_id, and app_id. Discover the app ID using get_project_apps or get_project_app_by_slug:

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # Discover the website app
    website_app = await gc.project_apps.get_project_app_by_slug(
        id=org_id,
        project_id=project_id,
        app_slug="website",
    )
    app_id = website_app["id"]

    # List all pages
    pages = await gc.website.get_website_pages(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
    )
    for page in pages["data"]:
        print(f"{page['title']} - /{page['slug']}")

    # Get a single page with full block content
    page = await gc.website.get_website_page(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        page_id="b2c3d4e5-6789-abcd-ef01-234567890abc",
    )
    print(page["title"])    # "About Us"
    print(page["sections"]) # [{...}, {...}] -- full section/block tree

    # List blog posts
    posts = await gc.website.get_website_posts(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        page="1",
        page_size="10",
    )

    # Search pages by title
    results = await gc.website.get_website_pages(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        search="pricing",
    )

    # List headers, footers, templates, sidebars, dialogs
    headers = await gc.website.list_website_headers(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    footers = await gc.website.list_website_footers(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    templates = await gc.website.list_website_templates(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )

    # Get page URLs for sitemap generation
    urls = await gc.website.get_website_urls(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )

Working with Email

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # Discover the email app
    email_app = await gc.project_apps.get_project_app_by_slug(
        id=org_id, project_id=project_id, app_slug="email",
    )
    app_id = email_app["id"]

    # List email templates
    emails = await gc.email.get_emails(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    for email in emails["data"]:
        print(f"{email['name']} ({email['subject']})")

    # Get a specific email template
    email = await gc.email.get_email(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        email_id="c3d4e5f6-789a-bcde-f012-3456789abcde",
    )

    # List campaigns and their send history
    campaigns = await gc.email.get_email_campaigns(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    campaign = campaigns["data"][0]
    sends = await gc.email.get_email_campaign_sends(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        campaign_id=campaign["id"],
    )

    # List segments and get contact count
    segments = await gc.email.list_email_segments(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    for segment in segments["data"]:
        count = await gc.email.get_email_segment_count(
            organization_id=org_id,
            project_id=project_id,
            app_id=app_id,
            segment_id=segment["id"],
        )
        print(f"{segment['name']}: {count['count']} contacts")

Working with CRM

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # Discover the CRM app
    crm_app = await gc.project_apps.get_project_app_by_slug(
        id=org_id, project_id=project_id, app_slug="crm",
    )
    app_id = crm_app["id"]

    # List contacts with search
    contacts = await gc.crm.get_crm_contacts_list(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        search="jane",
    )
    for contact in contacts["data"]:
        print(f"{contact['name']} <{contact['email']}>")

    # Get a specific contact and their activity history
    contact = await gc.crm.get_crm_contact(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        contact_id="e5f6a7b8-9012-cdef-3456-789abcdef012",
    )
    activities = await gc.crm.get_crm_contact_activities(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        contact_id=contact["id"],
    )

    # List companies
    companies = await gc.crm.get_crm_companies_list(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )

    # Get contacts for a specific company
    company_contacts = await gc.crm.get_crm_company_contacts(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        company_id=companies["data"][0]["id"],
    )

Working with Forms

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # Discover the forms app
    forms_app = await gc.project_apps.get_project_app_by_slug(
        id=org_id, project_id=project_id, app_slug="forms",
    )
    app_id = forms_app["id"]

    # List all forms
    forms = await gc.forms.get_forms_list(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    for form in forms["data"]:
        print(f"{form['name']} (id: {form['id']})")

    # Get a specific form's definition (fields, validation rules)
    form = await gc.forms.get_form(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        form_id="f6a7b8c9-0123-def4-5678-9abcdef01234",
    )

    # List submissions for a form
    submissions = await gc.forms.get_form_submissions(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        form_id=form["id"],
        page="1",
        page_size="50",
    )
    for sub in submissions["data"]:
        print(f"  Submitted at {sub['createdAt']}: {sub['data']}")

Working with Knowledge Base

Knowledge base resources are under gc.other:

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # Discover the KB app
    kb_app = await gc.project_apps.get_project_app_by_slug(
        id=org_id, project_id=project_id, app_slug="kb",
    )
    app_id = kb_app["id"]

    # List categories
    categories = await gc.other.list_kb_categories(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )
    for cat in categories:
        print(f"{cat['name']} (id: {cat['id']})")

    # List articles, optionally filtered by category or status
    articles = await gc.other.list_kb_articles(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        status="published",
        search="getting started",
    )
    for article in articles["data"]:
        print(f"{article['title']}")

    # Get a single article with full content
    article = await gc.other.get_kb_article(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        article_id=articles["data"][0]["id"],
    )

    # Get KB settings
    settings = await gc.other.get_kb_settings(
        organization_id=org_id, project_id=project_id, app_id=app_id,
    )

Working with Files

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # List files in a project
    files = await gc.project_files.get_files(
        id=org_id, project_id=project_id,
    )
    for f in files["data"]:
        print(f"{f['name']} ({f['mimeType']}, {f['size']} bytes)")

    # Search files by content (semantic search)
    results = await gc.project_files.search_project_files(
        id=org_id,
        project_id=project_id,
        query="quarterly revenue report",
        limit="5",
    )
    for result in results:
        print(f"{result['name']} (score: {result['score']})")

    # Get a specific file
    file = await gc.project_files.get_file(
        id=org_id,
        project_id=project_id,
        file_id="a7b8c9d0-1234-ef56-7890-abcdef012345",
    )

    # Create a file from text content (useful for programmatic content ingestion)
    new_file = await gc.project_files.ingest_file(
        id=org_id,
        project_id=project_id,
        data={
            "name": "meeting-notes-2026-04.md",
            "content": "# Q2 Planning\n\nKey decisions from today's meeting...",
            "mimeType": "text/markdown",
        },
    )
    print(f"Created file: {new_file['id']}")

    # List file folders
    folders = await gc.project_files.get_file_folders(
        id=org_id, project_id=project_id,
    )

    # List files in a specific folder
    folder_files = await gc.project_files.get_files(
        id=org_id,
        project_id=project_id,
        folder_id=folders[0]["id"],
    )

    # Find everywhere a file is referenced (pages, emails, etc.)
    refs = await gc.project_files.get_file_references(
        id=org_id,
        project_id=project_id,
        file_id="a7b8c9d0-1234-ef56-7890-abcdef012345",
    )
    for ref in refs:
        print(f"Used in {ref['type']}: {ref['title']}")

Working with Drafts

Drafts are AI-generated content items. The typical workflow is: trigger generation (via the console or API), then poll for completion.

import asyncio

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # List all drafts for a project
    drafts = await gc.drafts.list_drafts(
        id=org_id, project_id=project_id,
    )
    for draft in drafts["data"]:
        print(f"{draft['title']} [{draft['status']}]")
        # status: "pending", "generating", "ready", "failed"

    # Get a specific draft (includes full generated content when ready)
    draft = await gc.drafts.get_draft(
        id=org_id,
        project_id=project_id,
        draft_id="b8c9d0e1-2345-f678-90ab-cdef01234567",
    )

    # Request an AI edit of existing content
    edit = await gc.drafts.edit_draft(data={
        "organizationId": org_id,
        "projectId": project_id,
        "contentType": "page",
        "contentId": "c9d0e1f2-3456-7890-abcd-ef0123456789",
        "instructions": "Make the hero section more compelling and add a CTA button",
    })
    draft_id = edit["id"]

    # Poll until the draft is ready
    while True:
        draft = await gc.drafts.get_draft(
            id=org_id, project_id=project_id, draft_id=draft_id,
        )
        if draft["status"] in ("ready", "failed"):
            break
        await asyncio.sleep(2)

    if draft["status"] == "ready":
        print(f"Draft ready: {draft['title']}")

Working with Ideas

Ideas are suggestions generated by Mind, the AI engine. They can be approved (which creates a draft) or dismissed.

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"

    # List all ideas for a project
    ideas = await gc.ideas.list_ideas(id=org_id, project_id=project_id)
    for idea in ideas["data"]:
        print(f"[{idea['status']}] {idea['title']}: {idea['description']}")

    # Get a specific idea
    idea = await gc.ideas.get_idea(
        id=org_id,
        project_id=project_id,
        idea_id="d0e1f2a3-4567-890a-bcde-f01234567890",
    )

    # Approve an idea (triggers draft generation)
    result = await gc.ideas.approve_idea(
        id=org_id,
        project_id=project_id,
        idea_id=idea["id"],
        data={"feedback": "Sounds good, please generate this"},
    )

    # Dismiss an idea
    await gc.ideas.dismiss_idea(
        id=org_id,
        project_id=project_id,
        idea_id="e1f2a3b4-5678-90ab-cdef-012345678901",
        data={"reason": "Not relevant to our current strategy"},
    )

Pagination

List endpoints return paginated results. Use page and page_size to control pagination:

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    org_id = "d4e5f6a7-1234-5678-9abc-def012345678"
    project_id = "a1b2c3d4-5678-9abc-def0-123456789abc"
    app_id = "e5f6a7b8-9012-cdef-3456-789abcdef012"

    # First page, 10 items
    result = await gc.website.get_website_pages(
        organization_id=org_id,
        project_id=project_id,
        app_id=app_id,
        page="1",
        page_size="10",
    )

    pages = result["data"]            # list of page objects
    pagination = result["pagination"]  # {"page": 1, "pageSize": 10, "total": 47}

    # Iterate through all pages
    all_pages = []
    current_page = 1
    while True:
        result = await gc.website.get_website_pages(
            organization_id=org_id,
            project_id=project_id,
            app_id=app_id,
            page=str(current_page),
            page_size="25",
        )
        all_pages.extend(result["data"])
        total = result["pagination"]["total"]
        if len(all_pages) >= total:
            break
        current_page += 1

    print(f"Fetched {len(all_pages)} pages total")

Error Handling

The SDK raises httpx.HTTPStatusError for non-2xx responses. The error response body contains a structured JSON message:

import httpx

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    try:
        project = await gc.projects.get_project(
            id="d4e5f6a7-1234-5678-9abc-def012345678",
            project_id="nonexistent-id",
        )
    except httpx.HTTPStatusError as e:
        print(e.response.status_code)  # 404
        print(e.response.json())       # {"message": "Project not found", "code": "NOT_FOUND"}

Common error codes:

Status	Code	Meaning
400	BAD_REQUEST	Invalid request body or parameters
401	UNAUTHORIZED	Invalid or expired API key
403	FORBIDDEN	Insufficient permissions for this resource
404	NOT_FOUND	Resource does not exist
409	CONFLICT	Resource already exists or state conflict
429	RATE_LIMITED	Too many requests, retry after backoff
500	INTERNAL_ERROR	Server error, contact support

Request IDs and Tracing

Every API response includes an x-request-id header. Include this when reporting issues to support:

import httpx

async with create_giant_context(api_key=os.environ["GIANTCONTEXT_API_KEY"]) as gc:
    try:
        await gc.projects.get_project(
            id="d4e5f6a7-1234-5678-9abc-def012345678",
            project_id="nonexistent-id",
        )
    except httpx.HTTPStatusError as e:
        request_id = e.response.headers.get("x-request-id")
        print(f"Request failed. Request ID: {request_id}")
        # Include this ID when contacting support

Configuration

import os
from giantcontext import create_giant_context

gc = create_giant_context(
    # Required. Your API key (format: gct_*).
    # Get one from the Giant Context console: Settings > API Keys.
    api_key=os.environ["GIANTCONTEXT_API_KEY"],

    # Optional. API base URL. Default: "https://api.giantcontext.com"
    base_url="https://api.giantcontext.com",

    # Optional. Request timeout in seconds. Default: 30.0
    timeout=30.0,
)

Parameter	Type	Default	Description
api_key	str	required	API key starting with gct_
base_url	str	https://api.giantcontext.com	API base URL
timeout	float	30.0	Request timeout in seconds

API Reference

110 methods across 23 resources.

• API Keys (2)
• App Members (2)
• Bug Reports (2)
• CRM (9)
• Chat (2)
• Drafts (3)
• Email (13)
• Feature Requests (3)
• Forms (4)
• Ideas (4)
• Invitations (2)
• Me (6)
• Organization Members (4)
• Organizations (4)
• Other (5)
• Project Apps (4)
• Project Branding (2)
• Project Domains (2)
• Project Files (8)
• Project Members (2)
• Project Trash (2)
• Projects (4)
• Website (21)

API Keys

gc.api_keys

list_my_api_keys

Get my API keys Returns all active API keys belonging to the current user. Each key includes its ID, name, creation date, expiration date, and associated organization. The secret key value is not returned for security.

Returns: dict[str, Any]

result = await gc.api_keys.list_my_api_keys()

---

list_organization_api_keys

Get organization API keys Returns all active API keys for an organization. Each key object includes its ID, name, creation date, expiration date, and the user it is associated with. The secret key value is never returned in list responses. Requires admin or owner role within the organization.

Parameter	Type	Required
id	str	Yes

Returns: dict[str, Any]

result = await gc.api_keys.list_organization_api_keys(
    id="uuid-id",
)

---

App Members

gc.app_members

get_app_member

Get an app member by ID Retrieves the full details of a specific app member by their membership ID. Returns the member's user profile information (name, email, avatar) along with their assigned role within the app and membership timestamps.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
app_id	str	Yes
member_id	str	Yes

Returns: dict[str, Any]

result = await gc.app_members.get_app_member(
    id="uuid-id",
    project_id="uuid-project",
    app_id="uuid-app",
    member_id="uuid-member",
)

---

get_app_members

Get members of an app Returns a paginated list of all members who have been explicitly assigned roles at the app level. Each member entry includes the user's profile information (name, email, avatar) and their assigned role within the app. This is separate from organization-level or project-level membership; only users with direct app-level role assignments are returned.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.app_members.get_app_members(
    id="uuid-id",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

Bug Reports

gc.bug_reports

list_my_bug_reports

Get my bug reports Returns all bug reports submitted by the current user (up to 100). Each report includes its title, description, steps to reproduce, expected/actual behavior, severity, status (open/resolved/cancelled), browser info, page URL, report count, and linked GitHub issue details if any.

Returns: dict[str, Any]

result = await gc.bug_reports.list_my_bug_reports()

---

get_bug_report_comments

Get comments for a bug report Returns all team comments and responses for a specific bug report owned by the current user. Each comment includes its ID, the comment text, the author name, and a creation timestamp. Comments are returned in chronological order.

Parameter	Type	Required
id	str	Yes

Returns: dict[str, Any]

result = await gc.bug_reports.get_bug_report_comments(
    id="uuid-id",
)

---

CRM

gc.crm

get_crm_activity

Get activity Returns a single CRM activity by ID, including type, subject, description, notes, duration, outcome, due date, completion status, assignee, and linked contact/company objects.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
activity_id	str	Yes

Returns: dict[str, Any]

result = await gc.crm.get_crm_activity(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    activity_id="uuid-activity",
)

---

get_crm_activities_list

Get activities Returns a paginated list of all CRM activities for the specified app. Supports search by subject or description. Each activity includes linked contact and company objects.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.crm.get_crm_activities_list(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_crm_company_activities

Get activities for a company Returns all CRM activities linked to a specific company, ordered by most recent first. Each activity includes type, subject, description, notes, outcome, duration, due date, and linked contact/company objects.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
company_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.crm.get_crm_company_activities(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    company_id="uuid-company",
)

---

get_crm_company_contacts

Get contacts for a company Returns all CRM contacts linked to a specific company, ordered by last name then first name. Each contact includes name, email, phone, title, department, status, source, tags, and linked company object.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
company_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.crm.get_crm_company_contacts(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    company_id="uuid-company",
)

---

get_crm_company

Get company Returns a single CRM company by ID, including name, website, industry, size, annual revenue, contact info, address, tags, custom properties, and a count of associated contacts.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
company_id	str	Yes

Returns: dict[str, Any]

result = await gc.crm.get_crm_company(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    company_id="uuid-company",
)

---

get_crm_companies_list

Get companies Returns a paginated list of all CRM companies for the specified app. Supports search by company name or industry. Each company includes a count of associated contacts.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.crm.get_crm_companies_list(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_crm_contact_activities

Get activities for a contact Returns all CRM activities linked to a specific contact, ordered by most recent first. Each activity includes type, subject, description, notes, outcome, duration, due date, and linked contact/company objects.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
contact_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.crm.get_crm_contact_activities(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    contact_id="uuid-contact",
)

---

get_crm_contact

Get contact Returns a single CRM contact by ID, including linked company details. Fields include name, email, phone, title, department, status, source, tags, email subscription status, and last activity timestamp.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
contact_id	str	Yes

Returns: dict[str, Any]

result = await gc.crm.get_crm_contact(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    contact_id="uuid-contact",
)

---

get_crm_contacts_list

Get contacts Returns a paginated list of all CRM contacts for the specified app. Supports search by first name, last name, or email. Each contact includes associated company info if linked.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.crm.get_crm_contacts_list(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

Chat

gc.chat

get_chat_conversation

Get chat conversation with paginated messages Retrieve a chat conversation with cursor-based paginated messages. Without a cursor, returns the most recent messages (up to limit). Use direction=older with cursor/cursorId to load history.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
conversation_id	str	Yes
cursor	str	No
cursor_id	str	No
direction	str	No
limit	str	No

Returns: dict[str, Any]

result = await gc.chat.get_chat_conversation(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    conversation_id="uuid-conversation",
)

---

list_chat_conversations

Get all chat conversations List all chat conversations for a given chat app. Returns a paginated list of conversations with their IDs, titles, visitor IDs, and timestamps. Supports search filtering by conversation title or visitor ID. Results are ordered by most recently updated first. This is an admin-only endpoint used to review and manage all customer chat conversations.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.chat.list_chat_conversations(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

Drafts

gc.drafts

edit_draft

Create an edit draft Creates a draft copy of existing content for non-destructive editing. The original stays untouched until the draft is accepted. On accept, the copy's content replaces the original. On reject, the copy is deleted.

Parameter	Type	Required
data	dict	Yes

Returns: dict[str, Any]

result = await gc.drafts.edit_draft(
    data={...},
)

---

get_draft

Get a draft by ID Retrieves the full details of a single AI-generated content draft including the prompt, generated content, tool calls, and sources.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
draft_id	str	Yes

Returns: dict[str, Any]

result = await gc.drafts.get_draft(
    id="uuid-id",
    project_id="uuid-project",
    draft_id="uuid-draft",
)

---

list_drafts

List drafts for a project Returns a paginated list of AI-generated content drafts for the specified project. Supports filtering by status and sorting.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
page	str	No
page_size	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.drafts.list_drafts(
    id="uuid-id",
    project_id="uuid-project",
    page=1,
)

---

Email

gc.email

get_email_campaign

Get campaign Returns a single email campaign by ID, including name, subject, status, email template reference, segment, scheduling info, and send statistics.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
campaign_id	str	Yes

Returns: dict[str, Any]

result = await gc.email.get_email_campaign(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    campaign_id="uuid-campaign",
)

---

get_email_campaign_sends

Get campaign sends Returns the send history for a specific campaign. Each send record includes the recipient contact, delivery status (pending/sent/delivered/bounced/failed), open/click tracking, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
campaign_id	str	Yes
limit	str	No
offset	str	No

Returns: list[dict[str, Any]]

result = await gc.email.get_email_campaign_sends(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    campaign_id="uuid-campaign",
)

---

get_email_campaigns

Get campaigns Returns a paginated list of all email campaigns for the specified app. Each campaign includes its name, subject, status (draft/scheduled/sent), associated email template, segment, and send statistics.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.email.get_email_campaigns(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_email

Get email template Returns a single email template by ID, including name, subject line, full content blocks, header/footer references, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
email_id	str	Yes

Returns: dict[str, Any]

result = await gc.email.get_email(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    email_id="uuid-email",
)

---

get_emails

Get email templates Returns a list of all email templates for the specified app. Each template includes its name, subject line, content blocks, and associated header/footer references.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.email.get_emails(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_email_footer

Get email footer Returns a single email footer by ID, including its name, content blocks, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
footer_id	str	Yes

Returns: dict[str, Any]

result = await gc.email.get_email_footer(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    footer_id="uuid-footer",
)

---

list_email_footers

Get email footers Returns a list of all email footers for the specified app. Footers contain branding, unsubscribe links, and legal text appended to emails.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.email.list_email_footers(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_email_header

Get email header Returns a single email header by ID, including its name, content blocks, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
header_id	str	Yes

Returns: dict[str, Any]

result = await gc.email.get_email_header(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    header_id="uuid-header",
)

---

list_email_headers

Get email headers Returns a list of all email headers for the specified app. Headers contain branding and navigation elements prepended to emails.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.email.list_email_headers(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_email_segment_contacts

Get contacts in segment Returns the list of CRM contacts that match the specified segment's filter criteria. Each contact includes name, email, phone, status, and other profile fields.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
segment_id	str	Yes
limit	str	No

Returns: list[dict[str, Any]]

result = await gc.email.get_email_segment_contacts(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    segment_id="uuid-segment",
)

---

get_email_segment_count

Get segment contact count Returns the count of CRM contacts that match the specified segment's filter criteria. Useful for previewing audience size before sending a campaign.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
segment_id	str	Yes

Returns: dict[str, Any]

result = await gc.email.get_email_segment_count(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    segment_id="uuid-segment",
)

---

get_email_segment

Get email segment Returns a single email segment by ID, including its name, filter rules, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
segment_id	str	Yes

Returns: dict[str, Any]

result = await gc.email.get_email_segment(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    segment_id="uuid-segment",
)

---

list_email_segments

Get email segments Returns a list of all email segments for the specified app. Segments define targeting criteria for campaigns based on contact attributes and behavior.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.email.list_email_segments(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

Feature Requests

gc.feature_requests

get_popular_feature_requests

Get popular feature requests Returns all non-merged, non-cancelled feature requests sorted by vote count. Includes whether the current user has voted for each request and the comment count. Does not expose user identity information for privacy.

Parameter	Type	Required
limit	str	No
offset	str	No
status	str	No

Returns: dict[str, Any]

result = await gc.feature_requests.get_popular_feature_requests()

---

list_my_feature_requests

Get my feature requests Returns all feature requests submitted by the current user (up to 100). Each request includes its title, description, priority, status (open/planned/shipped/cancelled), vote count, and linked GitHub issue details if any.

Returns: dict[str, Any]

result = await gc.feature_requests.list_my_feature_requests()

---

get_feature_request_comments

Get comments for a feature request Returns all team comments and responses for a specific feature request owned by the current user. Each comment includes its ID, the comment text, the author name, and a creation timestamp. Comments are returned in chronological order.

Parameter	Type	Required
id	str	Yes

Returns: dict[str, Any]

result = await gc.feature_requests.get_feature_request_comments(
    id="uuid-id",
)

---

Forms

gc.forms

get_form

Get form Retrieve the full details of a single form by its identifier. Returns the form's unique identifier, associated app identifier, name, URL slug, description, field definitions (each with name, type, and required status), rich content layout (Builder block structure used for rendering), settings (notification email, redirect URL, tags, source), active/inactive status, and creation and update timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
form_id	str	Yes

Returns: dict[str, Any]

result = await gc.forms.get_form(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    form_id="uuid-form",
)

---

get_form_submission

Get form submission Retrieve the full details of a single form submission by its identifier. Returns the submission's unique identifier, the parent form identifier, the complete user-submitted data (key-value pairs corresponding to form fields), metadata (user agent, IP address, referer, submission timestamp, tags, source), and the creation timestamp.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
form_id	str	Yes
submission_id	str	Yes

Returns: dict[str, Any]

result = await gc.forms.get_form_submission(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    form_id="uuid-form",
    submission_id="uuid-submission",
)

---

get_form_submissions

Get form submissions Retrieve a paginated list of all submissions received for a specific form. Each submission includes its unique identifier, the parent form identifier, the user-submitted data (key-value pairs corresponding to form fields), metadata (user agent, IP address, referer, submission timestamp, tags, source), and the creation timestamp. Supports full-text search across submission data.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
form_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.forms.get_form_submissions(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    form_id="uuid-form",
    page=1,
)

---

get_forms_list

Get forms Retrieve a paginated list of all forms belonging to the specified Forms app. Each form in the response includes its unique identifier, name, URL slug, description, field definitions (name, type, required status), rich content layout, settings (notification email, redirect URL), active/inactive status, creation and update timestamps, and a count of how many submissions have been received. Supports searching forms by name or slug.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.forms.get_forms_list(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

Ideas

gc.ideas

approve_idea

Approve a Mind idea Approve an idea, which sets its status to 'approved'. If the project has auto-draft enabled, this also triggers draft generation automatically. The idea must be in 'pending' status.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
idea_id	str	Yes
data	dict	Yes

Returns: dict[str, Any]

result = await gc.ideas.approve_idea(
    id="uuid-id",
    project_id="uuid-project",
    idea_id="uuid-idea",
    data={...},
)

---

dismiss_idea

Dismiss a Mind idea Dismiss an idea that the user doesn't want to pursue. The idea must be in 'pending' status. Optionally include a reason for dismissal. Dismissed ideas are tracked so Mind doesn't re-suggest them.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
idea_id	str	Yes
data	dict	Yes

Returns: dict[str, Any]

result = await gc.ideas.dismiss_idea(
    id="uuid-id",
    project_id="uuid-project",
    idea_id="uuid-idea",
    data={...},
)

---

get_idea

Get a Mind idea Returns full details of a Mind idea including title, rationale, outline, priority, similarity score, and status. If the idea has status 'pending', it can be approved (triggering draft generation) or dismissed.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
idea_id	str	Yes

Returns: dict[str, Any]

result = await gc.ideas.get_idea(
    id="uuid-id",
    project_id="uuid-project",
    idea_id="uuid-idea",
)

---

list_ideas

List Mind ideas for a project Returns a paginated list of Mind ideas for the project. Ideas represent content gaps or suggestions identified by the AI ideation engine. Filter by status to see pending, approved, dismissed, or drafted ideas.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: dict[str, Any]

result = await gc.ideas.list_ideas(
    id="uuid-id",
    project_id="uuid-project",
)

---

Invitations

gc.invitations

get_organization_invitation

Get an invitation by ID Retrieves a single invitation by its ID within an organization. Returns the invitation object including invitee email, assigned role, status (pending, accepted, expired), creator, and timestamps. The 'id' param is the organization UUID and 'invitationId' is the invitation UUID. Returns 404 if the invitation does not exist.

Parameter	Type	Required
id	str	Yes
invitation_id	str	Yes

Returns: dict[str, Any]

result = await gc.invitations.get_organization_invitation(
    id="uuid-id",
    invitation_id="uuid-invitation",
)

---

get_organization_invitations

Get organization invitations Returns a paginated list of pending, accepted, and expired invitations for an organization. Each invitation includes the invitee email, assigned role, status, creation date, and expiration. Supports search by email, filtering by status, and sorting. Requires owner or admin role within the organization.

Parameter	Type	Required
id	str	Yes

Returns: dict[str, Any]

result = await gc.invitations.get_organization_invitations(
    id="uuid-id",
)

---

Me

gc.me

get_my_suspension_messages

Get my suspension appeal messages Returns the full suspension appeal message thread for the current user. Each message includes the sender (user or admin), the message content, and a timestamp. Only available to users with an active or past suspension.

Returns: list[dict[str, Any]]

result = await gc.me.get_my_suspension_messages()

---

get_my_notifications

Get my notifications Returns a paginated list of notifications for the authenticated user. Supports filtering by read/unread status and notification type via query parameters. Each notification includes its type, title, message, read status, and associated resource reference.

Parameter	Type	Required
page	str	No
page_size	str	No
search	str	No
status	str	No

Returns: dict[str, Any]

result = await gc.me.get_my_notifications(
    page=1,
)

---

get_my_organizations

Get organizations I belong to Returns all organizations that the authenticated user is a member of. Each organization includes its ID, name, slug, logo URL, and the user's role within that organization (e.g. owner, admin, member).

Returns: list[dict[str, Any]]

result = await gc.me.get_my_organizations()

---

get_my_invitations

Get my pending invitations Returns a paginated list of pending organization invitations addressed to the current user's email. Each invitation includes the organization name, the role offered, who sent it, and when it was created. Supports standard pagination query parameters.

Returns: dict[str, Any]

result = await gc.me.get_my_invitations()

---

get_my_activities

Get my activity history Returns a paginated list of activities performed by or affecting the current user. Each activity includes the action taken, the resource type and ID involved, the actor, and a timestamp. Supports standard pagination query parameters (page, pageSize, sortBy, sortOrder).

Parameter	Type	Required
page	str	No
page_size	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.me.get_my_activities(
    page=1,
)

---

get_me

Get current user profile and permissions Returns the authenticated user's full profile including name, email, avatar, role (admin/editor/viewer), active status, notification preferences, suspension status, a list of all granted RBAC permissions, and organization memberships with roles. Auto-provisions new users on first login with a default viewer role.

Returns: dict[str, Any]

result = await gc.me.get_me()

---

Organization Members

gc.organization_members

get_member_project_memberships

Get member project memberships Returns a list of all projects in the organization along with the specified member's access level for each project. Each entry includes the project ID, name, and the member's role/permission level within that project (or null if they have no direct project membership). Useful for auditing a member's project access across the organization.

Parameter	Type	Required
id	str	Yes
member_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.organization_members.get_member_project_memberships(
    id="uuid-id",
    member_id="uuid-member",
)

---

get_organization_member_activities

Get member activities Returns a paginated activity feed for a specific member within an organization. Activities include actions the member has performed such as project updates, document edits, member management changes, and settings modifications. Each activity entry includes the action type, resource details, and timestamp. Supports pagination via page and pageSize query parameters.

Parameter	Type	Required
id	str	Yes
member_id	str	Yes
page	str	No
page_size	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.organization_members.get_organization_member_activities(
    id="uuid-id",
    member_id="uuid-member",
    page=1,
)

---

get_organization_member

Get a member by ID Retrieves a single organization member by their member ID. Returns the member object including user profile (name, email, avatar), role, title, and join date. The 'id' param is the organization UUID and 'memberId' is the member UUID. Returns 404 if the member does not exist in this organization.

Parameter	Type	Required
id	str	Yes
member_id	str	Yes

Returns: dict[str, Any]

result = await gc.organization_members.get_organization_member(
    id="uuid-id",
    member_id="uuid-member",
)

---

get_organization_members

Get organization members Returns a paginated list of all members in an organization. Each member object includes the member ID, user profile (name, email, avatar), role (owner, admin, member), title, and join date. Supports search by name or email, filtering by role, and sorting. Pagination is controlled via page and pageSize query parameters.

Parameter	Type	Required
id	str	Yes
page	str	No
page_size	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.organization_members.get_organization_members(
    id="uuid-id",
    page=1,
)

---

Organizations

gc.organizations

get_service_account

Get a service account Returns the full details of a specific service account, including its name, description, role, and creation metadata. Only organization owners and admins can view service account details.

Parameter	Type	Required
id	str	Yes
account_id	str	Yes

Returns: dict[str, Any]

result = await gc.organizations.get_service_account(
    id="uuid-id",
    account_id="uuid-account",
)

---

list_service_accounts

Get organization service accounts Returns all service accounts configured for the organization. Service accounts are non-human identities used for programmatic API access via API keys. Only organization owners and admins can view service accounts.

Parameter	Type	Required
id	str	Yes

Returns: dict[str, Any]

result = await gc.organizations.list_service_accounts(
    id="uuid-id",
)

---

get_organization_by_slug

Get organization by slug Retrieves a single organization by its URL-friendly slug (e.g. 'my-company'). Returns the full organization object including ID, name, slug, logo URL, plan, status, member count, and timestamps. Useful for resolving organizations from URLs or user input where the slug is known but the ID is not. Returns 404 if no organization matches the given slug.

Parameter	Type	Required
slug	str	Yes

Returns: dict[str, Any]

result = await gc.organizations.get_organization_by_slug(
    slug="my-slug",
)

---

get_organization

Get an organization by ID Retrieves a single organization by its unique ID. Returns the full organization object including name, slug, logo URL, plan, status, member count, and timestamps. Returns 404 if the organization does not exist.

Parameter	Type	Required
id	str	Yes

Returns: dict[str, Any]

result = await gc.organizations.get_organization(
    id="uuid-id",
)

---

Other

gc.other

get_kb_article

Get KB article Retrieves a single knowledge base article by its ID, including its full rich text content, publish status, SEO metadata, and associated category IDs. Returns 404 if the article does not exist or has been soft-deleted.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
article_id	str	Yes

Returns: dict[str, Any]

result = await gc.other.get_kb_article(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    article_id="uuid-article",
)

---

list_kb_articles

Get KB articles Lists all knowledge base articles for the specified app, with support for pagination, filtering by category, filtering by publish status, and full-text search across titles and slugs. Returns articles sorted by creation date (newest first) by default.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
category_id	str	No
status	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.other.list_kb_articles(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_kb_category

Get KB category Retrieves a single knowledge base category by its ID, including its name, slug, description, parent relationship, icon, and display order. Returns 404 if the category does not exist or has been soft-deleted.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
category_id	str	Yes

Returns: dict[str, Any]

result = await gc.other.get_kb_category(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    category_id="uuid-category",
)

---

list_kb_categories

Get KB categories Lists all knowledge base categories for the specified app, returned as a hierarchical tree structure. Categories are nested under their parent categories and sorted by their display order. Includes all active (non-deleted) categories.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.other.list_kb_categories(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_kb_settings

Get KB settings Retrieves the current configuration settings for the knowledge base app, including display preferences, branding, and behavioral options stored as a JSON settings object on the app record.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.other.get_kb_settings(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

Project Apps

gc.project_apps

get_project_app_by_slug

Get a project app by slug Retrieves the full details of a single app by its URL-friendly slug within the specified project. This is an alternative to looking up an app by ID when you have the human-readable slug instead. Returns the same complete app object as the get-by-ID endpoint including name, slug, app type, configuration, and timestamps.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
app_slug	str	Yes

Returns: dict[str, Any]

result = await gc.project_apps.get_project_app_by_slug(
    id="uuid-id",
    project_id="uuid-project",
    app_slug="my-app",
)

---

get_project_app

Get a project app by ID Retrieves the full details of a single app by its unique ID within the specified project. Returns the app's name, slug, app type, configuration settings, and timestamps. The app must belong to the specified project or a 404 error is returned.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_apps.get_project_app(
    id="uuid-id",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_deleted_project_apps

Get deleted apps in trash Returns a list of all soft-deleted (trashed) apps within the specified project. These are apps that have been deleted but not yet permanently removed. Each app includes its full details including name, slug, app type, and deletion timestamp. Trashed apps can be restored using the restore endpoint or permanently deleted using the permanent delete endpoint.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.project_apps.get_deleted_project_apps(
    id="uuid-id",
    project_id="uuid-project",
)

---

get_project_apps

Get apps in a project Returns a paginated list of all active (non-deleted) apps configured within the specified project. Apps represent individual applications such as websites, CRM instances, email campaigns, forms, knowledge bases, or chat widgets. Each app includes its unique ID, name, slug, app type, configuration, and timestamps. Supports pagination and search filtering.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_apps.get_project_apps(
    id="uuid-id",
    project_id="uuid-project",
)

---

Project Branding

gc.project_branding

get_project_branding

Get project branding Retrieves the full details of a specific branding configuration by its unique ID within the specified project. Returns the branding's name and complete set of visual identity settings including primary and secondary colors, font selections, logo URLs, favicon, and any other configured styling properties. The branding must belong to the specified project.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
branding_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_branding.get_project_branding(
    id="uuid-id",
    project_id="uuid-project",
    branding_id="uuid-branding",
)

---

list_project_brandings

Get project brandings Returns a paginated list of all branding configurations for the specified project. Projects can have multiple named branding profiles (e.g., 'Website Brand', 'LMS Brand'), each containing visual identity settings such as primary and secondary colors, font selections, logo URLs, and favicon. Each branding entry includes its unique ID, name, and the full set of configured styling properties.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_branding.list_project_brandings(
    id="uuid-id",
    project_id="uuid-project",
)

---

Project Domains

gc.project_domains

get_domain_verification_instructions

Get domain verification instructions Retrieves the DNS verification instructions for the specified custom domain. Returns the exact DNS record (type, name, and value) that must be added to the domain's DNS configuration at the domain registrar to prove ownership. This is required before the domain can be verified and used for serving content. The instructions include the CNAME or TXT record details needed for the verification process.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
domain_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_domains.get_domain_verification_instructions(
    id="uuid-id",
    project_id="uuid-project",
    domain_id="uuid-domain",
)

---

list_project_domains

Get all domains for a project Returns a comprehensive list of all domains (both auto-generated and custom) across all apps within the specified project. Each domain entry includes its hostname, verification status, whether it is generated or custom, whether it is the primary domain for its app, and the associated app name and slug. Domains are grouped by app and sorted with generated domains first and primary domains prioritized.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.project_domains.list_project_domains(
    id="uuid-id",
    project_id="uuid-project",
)

---

Project Files

gc.project_files

get_file_references

Get all places where a file is referenced Returns a comprehensive list of all entities that reference this file across the project. This includes pages, headers, footers, blog posts, templates, sidebars, dialogs, forms, and branding settings. Useful for understanding the impact of deleting or replacing a file.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
file_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.project_files.get_file_references(
    id="uuid-id",
    project_id="uuid-project",
    file_id="uuid-file",
)

---

get_file_folder

Get a file folder Retrieves the details of a single folder in the project file manager, including its name, parent folder ID, and creation metadata.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
folder_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_files.get_file_folder(
    id="uuid-id",
    project_id="uuid-project",
    folder_id="uuid-folder",
)

---

get_file

Get a file Retrieves the full details of a single file in the project file manager, including its filename, MIME type, size, dimensions, storage URL, alt text, caption, and folder assignment.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
file_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_files.get_file(
    id="uuid-id",
    project_id="uuid-project",
    file_id="uuid-file",
)

---

get_file_folders

Get file folders in a project Returns all folders in the project file manager. Optionally filter by parentId to list only child folders of a specific parent folder. Pass parentId='null' or omit it to list root-level folders. Folders are used to organize uploaded files (images, documents, media).

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.project_files.get_file_folders(
    id="uuid-id",
    project_id="uuid-project",
)

---

ingest_file

Create a file from text or image content Creates a file from raw text content (Markdown, Mermaid, CSV, JSON, YAML, plain text, etc.) or base64-encoded image data (PNG, JPG, GIF, WebP, SVG). The file is stored in the project and processed for AI embeddings (text) or image classification (images). Use this to ingest documents, notes, diagrams, structured data, or screenshots into the project knowledge base.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
data	dict	Yes

Returns: dict[str, Any]

result = await gc.project_files.ingest_file(
    id="uuid-id",
    project_id="uuid-project",
    data={...},
)

---

search_project_files

Search files by content Searches project files by their content using semantic/AI search. Returns files whose content matches the meaning of the query, along with the matching content snippet and a relevance score.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
query	str	Yes
limit	str	No

Returns: list[dict[str, Any]]

result = await gc.project_files.search_project_files(
    id="uuid-id",
    project_id="uuid-project",
    query="search term",
)

---

list_file_trash

Get items in trash Returns all soft-deleted files and folders currently in the project's file trash. Items remain in trash until they are restored or permanently deleted. Each item includes its original metadata and the date it was trashed.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.project_files.list_file_trash(
    id="uuid-id",
    project_id="uuid-project",
)

---

get_files

Get files in a project Returns a paginated list of files (images, documents, media) uploaded to the project file manager. Supports full-text search by filename, filtering by folder ID and MIME type, and standard pagination and sorting options. Files at the root level can be retrieved by passing folderId as 'null'.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
page	str	No
page_size	str	No
search	str	No
folder_id	str	No

Returns: dict[str, Any]

result = await gc.project_files.get_files(
    id="uuid-id",
    project_id="uuid-project",
    page=1,
)

---

Project Members

gc.project_members

get_project_member

Get a project member by ID Retrieves the full details of a single project member by their membership ID, including their user profile information, assigned role, and membership metadata.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
member_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_members.get_project_member(
    id="uuid-id",
    project_id="uuid-project",
    member_id="uuid-member",
)

---

get_project_members

Get project members Returns a paginated list of users who are members of the specified project, including their roles and profile information. Supports search by name, filtering, and sorting. Project members have access to project resources based on their assigned role.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
page	str	No
page_size	str	No

Returns: dict[str, Any]

result = await gc.project_members.get_project_members(
    id="uuid-id",
    project_id="uuid-project",
    page=1,
)

---

Project Trash

gc.project_trash

get_project_trash_item

Get a single trash item Retrieves the full details of a single item in the project trash by its trash record ID. Includes the original entity type, entity ID, name, deletion timestamp, and the stored entity data snapshot.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
trash_id	str	Yes

Returns: dict[str, Any]

result = await gc.project_trash.get_project_trash_item(
    id="uuid-id",
    project_id="uuid-project",
    trash_id="uuid-trash",
)

---

list_project_trash

Get all items in project trash Returns a paginated list of all soft-deleted resources across the entire project, including pages, posts, files, forms, and other entities. Supports filtering by entity type to narrow results. Each trash item includes the original entity metadata, deletion timestamp, and the user who deleted it.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes
type	str	No
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.project_trash.list_project_trash(
    id="uuid-id",
    project_id="uuid-project",
    page=1,
)

---

Projects

gc.projects

get_project_by_slug

Get project by slug Retrieves the full details of a single project by its URL-friendly slug within the specified organization. This is an alternative to looking up a project by its UUID when you have the human-readable slug from a URL or user input. Returns the same complete project object as the get-by-ID endpoint including name, slug, description, settings, and timestamps.

Parameter	Type	Required
id	str	Yes
project_slug	str	Yes

Returns: dict[str, Any]

result = await gc.projects.get_project_by_slug(
    id="uuid-id",
    project_slug="my-project",
)

---

get_project_urls

Get all project URLs Returns resolved relative URLs for all published content across all apps in the project. Includes pages, posts, articles, etc. with title, path, type, and SEO metadata. Used for link resolution in AI builders, menus, emails, and navigation.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: dict[str, Any]

result = await gc.projects.get_project_urls(
    id="uuid-id",
    project_id="uuid-project",
)

---

get_project

Get a project by ID Retrieves the full details of a single project by its unique ID within the specified organization. Returns the project's name, slug, description, settings, and timestamps. The project must belong to the specified organization or a 404 error is returned.

Parameter	Type	Required
id	str	Yes
project_id	str	Yes

Returns: dict[str, Any]

result = await gc.projects.get_project(
    id="uuid-id",
    project_id="uuid-project",
)

---

get_projects

Get projects in an organization Returns a paginated list of all projects belonging to the specified organization. Projects are the top-level containers that hold apps, brandings, and domains. Supports search filtering by project name and pagination via page and pageSize query parameters. Each project in the response includes its unique ID, name, slug, description, and timestamps.

Parameter	Type	Required
id	str	Yes
page	str	No
page_size	str	No
search	str	No

Returns: dict[str, Any]

result = await gc.projects.get_projects(
    id="uuid-id",
    page=1,
)

---

Website

gc.website

get_website_consent_settings

Get consent settings Returns the cookie consent and privacy settings configured for this website app, including banner text, consent categories, and GDPR/CCPA compliance options.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_consent_settings(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_website_dialog

Get dialog Returns a single website dialog by ID, including its name, type, trigger rules, content blocks, and display settings.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
dialog_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_dialog(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    dialog_id="uuid-dialog",
)

---

list_website_dialogs

Get dialogs Returns a list of all popup dialogs configured for this website app. Dialogs are used for modals, popups, banners, and slide-ins.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.list_website_dialogs(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_custom_domain

Get custom domain Returns a single custom domain by ID, including hostname, verification status, SSL status, DNS records needed, and primary flag.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
domain_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_custom_domain(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    domain_id="uuid-domain",
)

---

list_website_custom_domains

Get custom domains Returns a list of all custom domains configured for this website app, including verification status, SSL status, and whether each is the primary domain.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: list[dict[str, Any]]

result = await gc.website.list_website_custom_domains(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_website_footer

Get website footer Returns a single website footer by ID, including its name, content blocks, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
footer_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_footer(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    footer_id="uuid-footer",
)

---

list_website_footers

Get website footers Returns a list of all footer components for this website app. Footers are reusable layout sections displayed at the bottom of pages.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.list_website_footers(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_header

Get website header Returns a single website header by ID, including its name, content blocks, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
header_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_header(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    header_id="uuid-header",
)

---

list_website_headers

Get website headers Returns a list of all header components for this website app. Headers are reusable navigation/branding sections displayed at the top of pages.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.list_website_headers(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_page

Get website page Returns a single website page by ID, including title, slug, full content blocks, SEO metadata, publish status, and layout references (header, footer, sidebar).

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_page(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page_id="uuid-page",
)

---

get_website_pages

Get website pages Returns a list of all pages for this website app. Each page includes its title, slug, publish status, SEO metadata, and associated header/footer/sidebar references.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.get_website_pages(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_post

Get blog post Returns a single blog post by ID, including title, slug, full content blocks, excerpt, tags, author, featured image, SEO metadata, and publish status.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
post_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_post(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    post_id="uuid-post",
)

---

get_website_posts

Get blog posts Returns a paginated list of all blog posts for this website app. Each post includes title, slug, excerpt, publish status, author, tags, and featured image.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.get_website_posts(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_app_settings

Get website settings Returns the website app settings including global SEO defaults, favicon, social image, language, and theme configuration.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_app_settings(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_website_sidebar

Get website sidebar Returns a single website sidebar by ID, including its name, content blocks, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
sidebar_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_sidebar(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    sidebar_id="uuid-sidebar",
)

---

list_website_sidebars

Get website sidebars Returns a list of all sidebar components for this website app. Sidebars are reusable layout sections displayed alongside page content.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.list_website_sidebars(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_tags

Get website tags Returns a list of all tags used across pages and posts in this website app. Tags are used for categorization and filtering.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: list[str]

result = await gc.website.get_website_tags(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_website_template

Get website template Returns a single website template by ID, including its name, content blocks, layout structure, and timestamps.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
template_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_template(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    template_id="uuid-template",
)

---

list_website_templates

Get website templates Returns a list of all page templates for this website app. Templates provide reusable page layouts and content block structures.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes
page	str	No
page_size	str	No
search	str	No
lite	str	No

Returns: dict[str, Any]

result = await gc.website.list_website_templates(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
    page=1,
)

---

get_website_tracking_settings

Get tracking settings Returns the analytics and tracking configuration for this website app, including Google Analytics ID, custom scripts, and tracking pixel settings.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_tracking_settings(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

---

get_website_urls

Get existing website page URLs Returns a list of all existing page slugs for this website app. Use this to avoid generating duplicate URLs when creating new pages.

Parameter	Type	Required
organization_id	str	Yes
project_id	str	Yes
app_id	str	Yes

Returns: dict[str, Any]

result = await gc.website.get_website_urls(
    organization_id="uuid-organization",
    project_id="uuid-project",
    app_id="uuid-app",
)

Requirements

• Python 3.11+
• httpx

License

MIT