> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stackone.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Klaviyo

> 162 actions available for Klaviyo through StackOne. Use via Actions RPC, Toolset SDK, MCP, or A2A.

export const GettingStarted = ({connector}) => {
  const linkStyle = {
    textDecoration: 'none'
  };
  const authConfigGuides = connector?.authentication?.filter(a => a?.setupGuide) ?? [];
  const linkAccountGuides = connector?.authentication?.filter(a => a?.configGuide) ?? [];
  return <div style={{
    marginTop: '32px',
    paddingTop: '24px'
  }} className="getting-started-section">
      <div style={{
    fontSize: '20px',
    fontWeight: '600',
    marginBottom: '12px'
  }}>Getting Started</div>
      <Steps>
        <Step title="Create or Select a Project">
          Set up a new project or select an existing one. See the <a href="/guides/managing-projects" style={linkStyle}>Projects Guide</a>.
        </Step>
        <Step title="Configure the Connector">
          <>
            Enable the connector and set up auth configuration in your project. See <a href="/guides/explore-connectors" style={linkStyle}>Managing Connectors</a>.
            {authConfigGuides.length > 0 && <>
              <Columns cols={2}>
                {authConfigGuides.map(auth => <Card title="Auth Config" href={`/${auth.setupGuide}`} icon={connector.icon} horizontal>
                    {connector.name} - {auth.label}
                  </Card>)}
              </Columns> 
              </>}
          </>
        </Step>
        <Step title="Link an Account">
          <>
            Connect an account using <a href="/guides/embedding-stackone-hub" style={linkStyle}>StackOne Hub</a> or <a href="/guides/auth-link" style={linkStyle}>Auth Link</a>.
            {linkAccountGuides.length > 0 && <>
                <Columns cols={2}>
                  {linkAccountGuides.map(auth => <Card title="Link Account" href={`/${auth.configGuide}`} icon={connector.icon} horizontal>
                      {connector.name} - {auth.label}
                    </Card>)}
                </Columns>
              </>}
          </>
        </Step>
        <Step title="Use Actions">
          <>
            Invoke actions using one of the methods below:
            <ul style={{
    marginTop: '8px',
    paddingLeft: '20px'
  }}>
              <li style={{
    marginBottom: '4px'
  }}><a href="/mcp/quickstart" style={linkStyle}>MCP</a> – Model Context Protocol for AI assistants</li>
              <li style={{
    marginBottom: '4px'
  }}><a href="/a2a/quickstart" style={linkStyle}>A2A</a> – Agent-to-Agent protocol</li>
              <li style={{
    marginBottom: '4px'
  }}><a href="/agents/typescript/introduction" style={linkStyle}>AI Toolset (TypeScript)</a> – TypeScript SDK for AI agents</li>
              <li style={{
    marginBottom: '4px'
  }}><a href="/agents/python/introduction" style={linkStyle}>AI Toolset (Python)</a> – Python SDK for AI agents</li>
              <li style={{
    marginBottom: '4px'
  }}><a href="/platform/api-reference/actions/make-an-rpc-call-to-an-action" style={linkStyle}>Actions RPC</a> – Direct API calls</li>
              <li style={{
    marginBottom: '4px'
  }}><a href="/guides/playground" style={linkStyle}>Playground</a> – Test actions in the dashboard</li>
            </ul>
          </>
        </Step>
      </Steps>
    </div>;
};

export const ActionsLibrary = ({search, setSearch, filtered, sharedStyles = {}, KeyCell, ScopesCell, availableScopes, selectedScopes, setSelectedScopes}) => {
  const libraryStyles = {
    section: {
      marginTop: '24px',
      marginBottom: '16px'
    },
    sectionTitle: {
      fontSize: '18px',
      fontWeight: '600',
      marginBottom: '12px'
    },
    filterRow: {
      display: 'flex',
      gap: '12px',
      marginBottom: '12px',
      alignItems: 'stretch'
    },
    count: {
      fontSize: '12px',
      marginBottom: '8px'
    },
    tableContainer: {
      maxHeight: '500px',
      overflowY: 'auto',
      overflowX: 'auto',
      borderRadius: '8px',
      fontSize: '13px'
    },
    gridTable: {
      display: 'grid',
      minWidth: '600px',
      gridTemplateColumns: '200px 1fr'
    },
    gridTableWithScopes: {
      gridTemplateColumns: '200px 1fr 150px'
    },
    gridHeader: {
      display: 'contents'
    },
    gridHeaderCell: {
      position: 'sticky',
      top: 0,
      padding: '10px 12px',
      fontWeight: '600',
      zIndex: 1
    },
    gridRow: {
      display: 'contents'
    },
    gridCellAction: {
      padding: '10px 12px',
      fontWeight: '500'
    },
    gridCellKey: {
      padding: '10px 12px'
    },
    gridCellScopes: {
      padding: '10px 12px',
      fontSize: '12px'
    },
    gridCellDescription: {
      padding: '10px 12px'
    }
  };
  const styles = {
    ...libraryStyles,
    ...sharedStyles
  };
  const safeAvailableScopes = Array.isArray(availableScopes) ? availableScopes : [];
  const safeSelectedScopes = Array.isArray(selectedScopes) ? selectedScopes : [];
  const hasScopesColumn = safeAvailableScopes.length > 0;
  const hasScopeFilter = safeAvailableScopes.length > 0 && typeof setSelectedScopes === 'function';
  const ScopesCellComponent = ScopesCell || (() => null);
  return <div style={styles.section}>
      <div style={styles.sectionTitle}>Actions</div>
      <div style={styles.filterRow}>
        <SearchBar value={search} onChange={setSearch} placeholder="Search actions" />
        {hasScopeFilter && <FilterDropdown label="Scopes" items={safeAvailableScopes} selectedItems={safeSelectedScopes} onChange={setSelectedScopes} searchPlaceholder="Search scopes..." emptyLabel="No scopes found" />}
      </div>
      <div style={styles.count} className="actions-library-count">
        {filtered.length === 0 ? '0 actions found' : `${filtered.length} action${filtered.length !== 1 ? 's' : ''}`}
      </div>
      {}
      <div className="not-prose actions-library-table-container" style={styles.tableContainer}>
        <div style={{
    ...hasScopesColumn ? {
      ...styles.gridTable,
      ...styles.gridTableWithScopes
    } : styles.gridTable
  }}>
          {}
          <div style={styles.gridHeader}>
            <div style={styles.gridHeaderCell} className="actions-library-grid-header-cell">Action</div>
            <div style={styles.gridHeaderCell} className="actions-library-grid-header-cell">Description</div>
            {hasScopesColumn && <div style={styles.gridHeaderCell} className="actions-library-grid-header-cell">Required scopes</div>}
          </div>
          {}
          {filtered.map(a => <div key={a.id} style={styles.gridRow}>
              <div style={styles.gridCellAction} className="actions-library-grid-cell">
                <div>{a.label}</div>
                <div style={{
    marginTop: '4px'
  }}>
                  <KeyCell id={a.id} />
                </div>
              </div>
              <div style={styles.gridCellDescription} className="actions-library-grid-cell actions-library-grid-cell--description">{a.description}</div>
              {hasScopesColumn && <div style={styles.gridCellScopes} className="actions-library-grid-cell actions-library-grid-cell--scopes">
                  <ScopesCellComponent scopes={a.requiredScopes} actionId={a.id} />
                </div>}
            </div>)}
        </div>
      </div>
    </div>;
};

export const FilterDropdown = ({label, items, selectedItems, onChange, searchPlaceholder = 'Search...', emptyLabel = 'No items found', formatLabel}) => {
  const [dropdownOpen, setDropdownOpen] = React.useState(false);
  const [search, setSearch] = React.useState('');
  const [hoveredItem, setHoveredItem] = React.useState(null);
  const dropdownRef = React.useRef(null);
  const styles = {
    dropdownContainer: {
      position: 'relative'
    },
    dropdownTrigger: {
      display: 'flex',
      alignItems: 'center',
      gap: '8px',
      padding: '10px 14px',
      borderRadius: '8px',
      fontSize: '14px',
      cursor: 'pointer',
      whiteSpace: 'nowrap',
      minWidth: '160px',
      justifyContent: 'space-between'
    },
    dropdownMenu: {
      position: 'absolute',
      top: '100%',
      right: 0,
      marginTop: '4px',
      borderRadius: '8px',
      zIndex: 50,
      minWidth: '220px',
      maxHeight: '320px',
      display: 'flex',
      flexDirection: 'column'
    },
    dropdownHeader: {
      padding: '8px 12px'
    },
    selectActions: {
      display: 'flex',
      alignItems: 'center',
      gap: '8px',
      marginTop: '6px',
      fontSize: '12px'
    },
    selectActionBtn: {
      background: 'none',
      border: 'none',
      cursor: 'pointer',
      padding: '2px 4px',
      fontSize: '12px'
    },
    dropdownSearchInput: {
      width: '100%',
      padding: '8px 10px',
      borderRadius: '6px',
      fontSize: '13px',
      outline: 'none'
    },
    dropdownList: {
      overflowY: 'auto',
      maxHeight: '220px',
      padding: '4px 0'
    },
    dropdownItem: {
      display: 'flex',
      alignItems: 'center',
      gap: '10px',
      padding: '8px 12px',
      cursor: 'pointer',
      fontSize: '13px',
      transition: 'background-color 0.1s'
    },
    checkbox: {
      width: '16px',
      height: '16px',
      borderRadius: '4px',
      display: 'flex',
      alignItems: 'center',
      justifyContent: 'center',
      flexShrink: 0
    },
    checkmark: {
      color: 'white',
      fontSize: '10px',
      fontWeight: 'bold'
    },
    dropdownFooter: {
      padding: '8px 12px',
      display: 'flex',
      justifyContent: 'space-between',
      alignItems: 'center'
    },
    clearButton: {
      fontSize: '12px',
      cursor: 'pointer',
      padding: '4px 8px',
      borderRadius: '4px',
      border: 'none',
      background: 'none'
    },
    badge: {
      fontSize: '11px',
      fontWeight: '600',
      padding: '2px 6px',
      borderRadius: '10px',
      marginLeft: '4px'
    },
    chevron: {
      fontSize: '10px',
      transition: 'transform 0.15s'
    },
    noResults: {
      padding: '12px',
      textAlign: 'center',
      fontSize: '13px'
    }
  };
  const safeSelected = Array.isArray(selectedItems) ? selectedItems : [];
  const formatItemLabel = item => {
    if (typeof formatLabel === 'function') {
      return formatLabel(item);
    }
    return item;
  };
  const filteredItems = React.useMemo(() => {
    if (!search) return items;
    const searchLower = search.toLowerCase();
    return items.filter(item => {
      const labelText = formatItemLabel(item);
      return labelText.toLowerCase().includes(searchLower);
    });
  }, [items, search, formatLabel]);
  const isSelected = item => safeSelected.includes(item);
  const toggleItem = item => {
    const next = isSelected(item) ? safeSelected.filter(v => v !== item) : [...safeSelected, item];
    onChange(next);
  };
  const clearFilters = () => {
    onChange([]);
  };
  const selectAll = () => {
    onChange(items);
  };
  React.useEffect(() => {
    const handleClickOutside = e => {
      if (dropdownRef.current && !dropdownRef.current.contains(e.target)) {
        setDropdownOpen(false);
        setSearch('');
        setHoveredItem(null);
      }
    };
    document.addEventListener('mousedown', handleClickOutside);
    return () => document.removeEventListener('mousedown', handleClickOutside);
  }, []);
  return <div style={styles.dropdownContainer} ref={dropdownRef}>
      <button type="button" onClick={() => setDropdownOpen(!dropdownOpen)} style={styles.dropdownTrigger} className={`filter-dropdown__trigger${safeSelected.length > 0 ? ' filter-dropdown__trigger--active' : ''}`}>
        <span>
          {label}
          {safeSelected.length > 0 && <span style={styles.badge} className="filter-dropdown__badge">{safeSelected.length}</span>}
        </span>
        <span style={{
    ...styles.chevron,
    transform: dropdownOpen ? 'rotate(180deg)' : 'rotate(0deg)'
  }} className="filter-dropdown__chevron">
          ▼
        </span>
      </button>
      {dropdownOpen && <div style={styles.dropdownMenu} className="filter-dropdown__menu">
          <div style={styles.dropdownHeader} className="filter-dropdown__header">
            <input type="text" placeholder={searchPlaceholder} value={search} onChange={e => setSearch(e.target.value)} style={styles.dropdownSearchInput} className="filter-dropdown__search" autoFocus />
            <div style={styles.selectActions}>
              <button type="button" onClick={selectAll} style={styles.selectActionBtn} className="filter-dropdown__action-btn">
                Select all
              </button>
              <span className="filter-dropdown__separator">|</span>
              <button type="button" onClick={clearFilters} style={styles.selectActionBtn} className="filter-dropdown__action-btn">
                Clear
              </button>
            </div>
          </div>
          <div style={styles.dropdownList}>
            {filteredItems.length === 0 ? <div style={styles.noResults} className="filter-dropdown__no-results">{emptyLabel}</div> : filteredItems.map(item => {
    const itemClass = ['filter-dropdown__item', hoveredItem === item ? 'filter-dropdown__item--hovered' : '', isSelected(item) ? 'filter-dropdown__item--selected' : ''].filter(Boolean).join(' ');
    const checkboxClass = `filter-dropdown__checkbox${isSelected(item) ? ' filter-dropdown__checkbox--checked' : ''}`;
    return <div key={item} onClick={() => toggleItem(item)} onMouseEnter={() => setHoveredItem(item)} onMouseLeave={() => setHoveredItem(null)} style={styles.dropdownItem} className={itemClass}>
                    <div style={styles.checkbox} className={checkboxClass}>
                      {isSelected(item) && <span style={styles.checkmark}>✓</span>}
                    </div>
                    <span>{formatItemLabel(item)}</span>
                  </div>;
  })}
          </div>
        </div>}
    </div>;
};

export const SearchBar = ({value, onChange, placeholder = 'Search...'}) => {
  const baseStyle = {
    padding: '10px 14px',
    borderRadius: '8px',
    fontSize: '14px',
    outline: 'none',
    flex: 1,
    minWidth: 0
  };
  return <input type="text" placeholder={placeholder} value={value} onChange={e => onChange(e.target.value)} style={baseStyle} className="search-bar" />;
};

export const ConnectorPage = ({connector}) => {
  const styles = {
    header: {
      display: 'flex',
      alignItems: 'center',
      gap: '12px',
      marginBottom: '24px'
    },
    tagsRow: {
      display: 'flex',
      flexWrap: 'wrap',
      gap: '6px',
      marginTop: '8px'
    },
    releaseTag: {
      display: 'inline-block',
      padding: '2px 8px',
      borderRadius: '4px',
      fontSize: '11px',
      fontWeight: '500'
    },
    categoryTag: {
      display: 'inline-block',
      padding: '2px 8px',
      borderRadius: '4px',
      fontSize: '11px',
      fontWeight: '500'
    },
    icon: {
      width: '48px',
      height: '48px',
      borderRadius: '10px',
      padding: '2px'
    },
    title: {
      fontSize: '24px',
      fontWeight: '600'
    },
    subtitle: {
      fontSize: '14px'
    },
    authDescription: {
      fontSize: '14px',
      marginTop: 0
    },
    sectionTitle: {
      fontSize: '18px',
      fontWeight: '600',
      marginBottom: '12px'
    },
    codeWrapper: {
      position: 'relative',
      display: 'inline-flex',
      alignItems: 'center',
      maxWidth: '100%',
      cursor: 'pointer',
      overflowX: 'auto',
      overflowY: 'hidden',
      msOverflowStyle: 'none',
      scrollbarWidth: 'none'
    },
    code: {
      padding: '4px 8px',
      borderRadius: '4px',
      fontSize: '11px',
      display: 'inline-block',
      whiteSpace: 'nowrap',
      transition: 'background-color 0.15s'
    },
    tooltip: {
      position: 'absolute',
      top: '100%',
      left: '50%',
      transform: 'translateX(-50%)',
      padding: '6px 10px',
      borderRadius: '6px',
      fontSize: '11px',
      whiteSpace: 'nowrap',
      marginTop: '6px',
      zIndex: 50,
      maxWidth: '300px',
      wordBreak: 'break-all'
    },
    tooltipArrow: {
      position: 'absolute',
      bottom: '100%',
      left: '50%',
      transform: 'translateX(-50%)',
      borderWidth: '5px',
      borderStyle: 'solid',
      zIndex: 50
    }
  };
  const [search, setSearch] = React.useState('');
  const [copiedId, setCopiedId] = React.useState(null);
  const [selectedScopes, setSelectedScopes] = React.useState([]);
  const availableScopes = React.useMemo(() => {
    const set = new Set();
    connector.actions.forEach(a => {
      if (Array.isArray(a.requiredScopes)) {
        a.requiredScopes.forEach(s => {
          if (s) set.add(s);
        });
      }
    });
    return Array.from(set).sort();
  }, [connector.actions]);
  const filtered = React.useMemo(() => {
    const searchLower = search.toLowerCase();
    return connector.actions.filter(a => {
      const matchesSearch = a.label.toLowerCase().includes(searchLower) || a.description.toLowerCase().includes(searchLower) || a.id.toLowerCase().includes(searchLower);
      if (!matchesSearch) return false;
      if (selectedScopes.length === 0) return true;
      const scopes = Array.isArray(a.requiredScopes) ? a.requiredScopes : [];
      if (scopes.length === 0) return false;
      return selectedScopes.some(scope => scopes.includes(scope));
    });
  }, [connector.actions, search, selectedScopes]);
  const handleImageError = e => {
    e.target.style.display = 'none';
  };
  const formatCategoryLabel = cat => {
    const acronyms = ['ai', 'ats', 'crm', 'hris', 'iam', 'lms'];
    if (acronyms.includes(cat.toLowerCase())) {
      return cat.toUpperCase();
    }
    return cat.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
  };
  const ReleaseTag = () => {
    if (!connector.releaseStage || connector.releaseStage === 'ga') return null;
    const variantClass = connector.releaseStage === 'beta' ? 'connector-page-tag-beta' : 'connector-page-tag-preview';
    return <span style={styles.releaseTag} className={variantClass}>
        {connector.releaseStage.charAt(0).toUpperCase() + connector.releaseStage.slice(1)}
      </span>;
  };
  const CategoryTags = () => {
    if (!connector.categories || connector.categories.length === 0) return null;
    return <>
        {connector.categories.map(cat => <span key={cat} style={styles.categoryTag} className="connector-page-category-tag">
            {formatCategoryLabel(cat)}
          </span>)}
      </>;
  };
  const copyToClipboard = async (text, id) => {
    try {
      await navigator.clipboard.writeText(text);
      setCopiedId(id);
      setTimeout(() => setCopiedId(null), 1500);
    } catch (err) {
      console.error('Failed to copy:', err);
    }
  };
  const CopyChip = ({text, copyId}) => {
    const [isHovered, setIsHovered] = React.useState(false);
    const isCopied = copiedId === copyId;
    if (!text) {
      return null;
    }
    const codeClassName = `connector-page-code${isCopied ? ' connector-page-code--copied' : ''}`;
    return <div style={styles.codeWrapper} onMouseEnter={() => setIsHovered(true)} onMouseLeave={() => setIsHovered(false)} onClick={() => copyToClipboard(text, copyId)} title="">
        {(isHovered || isCopied) && <div style={styles.tooltip} className="connector-page-tooltip">
            {isCopied ? '✓ Copied!' : 'Click to copy'}
            <div style={styles.tooltipArrow} className="connector-page-tooltip-arrow" />
          </div>}
        <code style={styles.code} className={codeClassName}>
          {text}
        </code>
      </div>;
  };
  const KeyCell = ({id}) => <CopyChip text={id} copyId={id} />;
  const ScopesCell = ({scopes, actionId}) => {
    const scopeList = Array.isArray(scopes) ? scopes.filter(Boolean) : [];
    if (scopeList.length === 0) return null;
    return <div style={{
      display: 'flex',
      flexWrap: 'wrap',
      gap: '6px'
    }}>
        {scopeList.map(scope => <CopyChip key={scope} text={scope} copyId={`scopes:${actionId}:${scope}`} />)}
      </div>;
  };
  return <div>
      {}
      <div style={styles.header}>
        <img src={connector.icon} alt={connector.name} style={styles.icon} className="connector-page-icon" onError={handleImageError} />
        <div>
          <div style={styles.title}>{connector.name}</div>
          <div style={styles.subtitle} className="connector-page-subtitle">
            {connector.actions.length} actions · {connector.authentication.length} auth method{connector.authentication.length !== 1 ? 's' : ''}
          </div>
          {connector.releaseStage && connector.releaseStage !== 'ga' || connector.categories && connector.categories.length > 0 ? <div style={styles.tagsRow}>
              <ReleaseTag />
              <CategoryTags />
            </div> : null}
        </div>
      </div>

      {}
      <div style={styles.sectionTitle}>Authentication</div>
      <Columns cols={2}>        
        {connector.authentication.length > 0 ? connector.authentication.map(auth => {
    const authLabel = auth?.label || '';
    const authDescription = auth?.description;
    const configGuide = auth?.configGuide;
    const setupGuide = auth?.setupGuide;
    const hasConfigGuide = !!configGuide;
    const hasSetupGuide = !!setupGuide;
    const hasAnyGuide = hasConfigGuide || hasSetupGuide;
    return <Card key={authLabel} title={authLabel}>
                {authDescription && <p style={{
      ...styles.authDescription,
      marginBottom: hasAnyGuide ? '8px' : 0
    }} className="connector-page-auth-description">
                    {authDescription}
                  </p>}
                {hasAnyGuide && <span style={{
      fontSize: '14px'
    }}>
                    Guides: {hasSetupGuide && <a href={`/${setupGuide}`} style={{
      textDecoration: 'none'
    }}>Auth Config</a>}
                    {hasConfigGuide && hasSetupGuide && ', '}
                    {hasConfigGuide && <a href={`/${configGuide}`} style={{
      textDecoration: 'none'
    }}>Link Account</a>}
                  </span>}
              </Card>;
  }) : <>
            Contact StackOne for authentication details.
          </>}
      </Columns>

      <ActionsLibrary search={search} setSearch={setSearch} filtered={filtered} sharedStyles={{
    sectionTitle: styles.sectionTitle
  }} KeyCell={KeyCell} ScopesCell={ScopesCell} availableScopes={availableScopes} selectedScopes={selectedScopes} setSelectedScopes={setSelectedScopes} />

      <GettingStarted connector={connector} />

      {connector.documentation?.references?.length > 0 && <>
          <div style={styles.sectionTitle}>References</div>
          <Columns cols={2}>
            {connector.documentation.references.map(ref => {
    let safeHref;
    try {
      const parsed = new URL(ref.url);
      safeHref = parsed.protocol === 'http:' || parsed.protocol === 'https:' ? ref.url : undefined;
    } catch {
      safeHref = undefined;
    }
    return <Card key={`${ref.title}-${ref.url}`} title={ref.title} href={safeHref}>
                  {ref.description}
                </Card>;
  })}
          </Columns>
        </>}

    </div>;
};

export const connector = {
  "key": "klaviyo",
  "name": "Klaviyo",
  "icon": "https://stackone-logos.com/api/klaviyo/filled/png",
  "authentication": [{
    "label": "Private API Key",
    "description": "Best for server-side integrations within a single Klaviyo account. Never expose in client-side code.",
    "configGuide": "connectors/klaviyo/guides/link-account/private-api-key",
    "setupGuide": "connectors/klaviyo/guides/auth-config/private-api-key"
  }, {
    "label": "OAuth 2.0",
    "description": "Recommended for partner integrations and multi-account apps. Each user authorizes access to their own Klaviyo data.",
    "configGuide": "connectors/klaviyo/guides/link-account/oauth-2-0",
    "setupGuide": "connectors/klaviyo/guides/auth-config/oauth-2-0"
  }],
  "actions": [{
    "id": "klaviyo_get_accounts",
    "label": "Get Accounts",
    "description": "Retrieve all Klaviyo accounts associated with the current API key. Always returns exactly one account object per key.",
    "requiredScopes": ["accounts:read"]
  }, {
    "id": "klaviyo_get_account",
    "label": "Get Account",
    "description": "Retrieve detailed configuration for a specific Klaviyo account by its unique account ID.",
    "requiredScopes": ["accounts:read"]
  }, {
    "id": "klaviyo_list_campaigns",
    "label": "List Campaigns",
    "description": "List email, SMS, or push campaigns with required channel filter and optional sorting and pagination.",
    "requiredScopes": ["campaigns:read"]
  }, {
    "id": "klaviyo_get_campaign",
    "label": "Get Campaign",
    "description": "Retrieve complete details for a single campaign by its unique ID, including status, audiences, send strategy, and tracki...",
    "requiredScopes": ["campaigns:read"]
  }, {
    "id": "klaviyo_create_campaign",
    "label": "Create Campaign",
    "description": "Create a new email, SMS, or mobile push campaign as a draft. Requires specifying the channel, audiences, and at least on...",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_update_campaign",
    "label": "Update Campaign",
    "description": "Update campaign properties such as name, target audiences, send strategy, or tracking options before the campaign is sen...",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_delete_campaign",
    "label": "Delete Campaign",
    "description": "Permanently delete a campaign by ID. This action cannot be undone. Only Draft campaigns can be deleted.",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_clone_campaign",
    "label": "Clone Campaign",
    "description": "Duplicate an existing campaign to create a new Draft campaign, optionally giving it a new name.",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_get_campaign_recipient_estimation",
    "label": "Get Campaign Recipient Estimation",
    "description": "Get the current estimated number of recipients for a campaign based on its configured audiences.",
    "requiredScopes": ["campaigns:read"]
  }, {
    "id": "klaviyo_get_tags_for_campaign",
    "label": "Get Tags For Campaign",
    "description": "Retrieve all tags associated with a specific campaign for organizational and filtering purposes.",
    "requiredScopes": ["campaigns:read"]
  }, {
    "id": "klaviyo_get_messages_for_campaign",
    "label": "Get Messages For Campaign",
    "description": "Retrieve all campaign messages (email, SMS, or push variants) that belong to a specific campaign.",
    "requiredScopes": ["campaigns:read"]
  }, {
    "id": "klaviyo_get_campaign_message",
    "label": "Get Campaign Message",
    "description": "Retrieve full details for a specific campaign message by its unique ID, including channel-specific content and render op...",
    "requiredScopes": ["campaigns:read"]
  }, {
    "id": "klaviyo_update_campaign_message",
    "label": "Update Campaign Message",
    "description": "Update the content and settings of a campaign message, including channel-specific fields such as subject, body, sender i...",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_assign_template_to_campaign_message",
    "label": "Assign Template To Campaign Message",
    "description": "Assign an email template to a campaign message, creating a non-reusable snapshot of the template's HTML for that message...",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_send_campaign",
    "label": "Send Campaign",
    "description": "Trigger a campaign to send immediately (or at its configured scheduled time) by creating an asynchronous send job. Campa...",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_cancel_campaign_send",
    "label": "Cancel Campaign Send",
    "description": "Cancel an in-progress campaign send job or revert a scheduled campaign back to Draft status. Campaign must be in Schedul...",
    "requiredScopes": ["campaigns:write"]
  }, {
    "id": "klaviyo_list_catalog_items",
    "label": "List Catalog Items",
    "description": "List all product catalog items in the account with filtering by title, category, or IDs, sorting by creation date, and c..."
  }, {
    "id": "klaviyo_create_catalog_item",
    "label": "Create Catalog Item",
    "description": "Create a new product catalog item with title, description, URL, price, and images, optionally assigning it to one or mor...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_get_catalog_item",
    "label": "Get Catalog Item",
    "description": "Retrieve the full details of a specific catalog item by its compound ID, with optional variant inclusion and sparse fiel...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_update_catalog_item",
    "label": "Update Catalog Item",
    "description": "Update an existing catalog item's title, description, URL, price, images, or published status using PATCH semantics - on...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_delete_catalog_item",
    "label": "Delete Catalog Item",
    "description": "Permanently delete a catalog item by its compound ID, removing it from all recommendation feeds and product blocks.",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_bulk_create_catalog_items",
    "label": "Bulk Create Catalog Items",
    "description": "Submit an asynchronous bulk job to create up to 100 catalog items in a single request, returning a job ID to poll for co...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_bulk_update_catalog_items",
    "label": "Bulk Update Catalog Items",
    "description": "Submit an asynchronous bulk job to update up to 100 existing catalog items in a single request, returning a job ID to po...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_bulk_delete_catalog_items",
    "label": "Bulk Delete Catalog Items",
    "description": "Submit an asynchronous bulk job to permanently delete up to 100 catalog items in a single request, returning a job ID to...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_list_catalog_categories",
    "label": "List Catalog Categories",
    "description": "List all product catalog categories in the account with filtering by name or item membership, sorting by creation date,...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_create_catalog_category",
    "label": "Create Catalog Category",
    "description": "Create a new product catalog category with an external ID and display name, optionally assigning catalog items to it at...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_get_catalog_category",
    "label": "Get Catalog Category",
    "description": "Retrieve the full details of a specific catalog category by its compound ID, including its name and external ID.",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_update_catalog_category",
    "label": "Update Catalog Category",
    "description": "Update an existing catalog category's name or item associations using PATCH semantics - only supplied fields are changed...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_delete_catalog_category",
    "label": "Delete Catalog Category",
    "description": "Permanently delete a catalog category by its compound ID, removing the category grouping without deleting the items it c...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_bulk_create_catalog_categories",
    "label": "Bulk Create Catalog Categories",
    "description": "Submit an asynchronous bulk job to create up to 100 catalog categories in a single request, returning a job ID to poll f...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_bulk_update_catalog_categories",
    "label": "Bulk Update Catalog Categories",
    "description": "Submit an asynchronous bulk job to update up to 100 existing catalog categories in a single request, returning a job ID...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_bulk_delete_catalog_categories",
    "label": "Bulk Delete Catalog Categories",
    "description": "Submit an asynchronous bulk job to permanently delete up to 100 catalog categories in a single request, returning a job...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_list_catalog_variants",
    "label": "List Catalog Variants",
    "description": "List all product catalog variants in the account with filtering by item, SKU, title, or published status, sorting by cre...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_create_catalog_variant",
    "label": "Create Catalog Variant",
    "description": "Create a new catalog variant (size, color, or style variation) for an existing catalog item, with SKU, inventory, price,...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_get_catalog_variant",
    "label": "Get Catalog Variant",
    "description": "Retrieve the full details of a specific catalog variant by its compound ID, including SKU, inventory quantity, price, an...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_update_catalog_variant",
    "label": "Update Catalog Variant",
    "description": "Update an existing catalog variant's SKU, price, inventory quantity, title, images, or published status using PATCH sema...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_delete_catalog_variant",
    "label": "Delete Catalog Variant",
    "description": "Permanently delete a catalog variant by its compound ID, removing it from recommendation feeds and back-in-stock subscri...",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_bulk_create_catalog_variants",
    "label": "Bulk Create Catalog Variants",
    "description": "Submit an asynchronous bulk job to create up to 100 catalog variants in a single request, each linked to an existing par...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_bulk_update_catalog_variants",
    "label": "Bulk Update Catalog Variants",
    "description": "Submit an asynchronous bulk job to update up to 100 existing catalog variants in a single request, returning a job ID to...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_bulk_delete_catalog_variants",
    "label": "Bulk Delete Catalog Variants",
    "description": "Submit an asynchronous bulk job to permanently delete up to 100 catalog variants in a single request, returning a job ID...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_add_items_to_catalog_category",
    "label": "Add Items To Catalog Category",
    "description": "Additively associate one or more catalog items with a specific category without replacing existing item memberships.",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_remove_items_from_catalog_category",
    "label": "Remove Items From Catalog Category",
    "description": "Remove specific catalog items from a category's membership without affecting other items already in the category.",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_add_categories_to_catalog_item",
    "label": "Add Categories To Catalog Item",
    "description": "Additively assign one or more catalog categories to a specific item without replacing its existing category memberships.",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_remove_categories_from_catalog_item",
    "label": "Remove Categories From Catalog Item",
    "description": "Remove specific category assignments from a catalog item without affecting the item's other category memberships.",
    "requiredScopes": ["catalogs:write"]
  }, {
    "id": "klaviyo_create_back_in_stock_subscription",
    "label": "Create Back In Stock Subscription",
    "description": "Subscribe an existing profile to back-in-stock notifications for a specific catalog variant via EMAIL, PUSH, or SMS chan...",
    "requiredScopes": ["catalogs:read"]
  }, {
    "id": "klaviyo_create_client_event",
    "label": "Create Client Event",
    "description": "Track a client-side event from a browser or mobile app using the public API key. No server-side credentials required.",
    "requiredScopes": ["events:write"]
  }, {
    "id": "klaviyo_create_client_profile",
    "label": "Create Client Profile",
    "description": "Create or update a Klaviyo profile from client-side code using the public API key. Safe for use in browser and mobile ap...",
    "requiredScopes": ["profiles:write"]
  }, {
    "id": "klaviyo_list_coupons",
    "label": "List Coupons",
    "description": "List all coupons in the account with optional sparse fieldsets and cursor-based pagination.",
    "requiredScopes": ["coupons:read"]
  }, {
    "id": "klaviyo_create_coupon",
    "label": "Create Coupon",
    "description": "Create a new coupon container with a unique external ID, matching your e-commerce platform's coupon identifier.",
    "requiredScopes": ["coupons:write"]
  }, {
    "id": "klaviyo_get_coupon",
    "label": "Get Coupon",
    "description": "Retrieve complete details for a specific coupon by its unique Klaviyo coupon ID.",
    "requiredScopes": ["coupons:read"]
  }, {
    "id": "klaviyo_update_coupon",
    "label": "Update Coupon",
    "description": "Update the description or monitor configuration of an existing coupon. The external_id cannot be changed after creation....",
    "requiredScopes": ["coupons:write"]
  }, {
    "id": "klaviyo_delete_coupon",
    "label": "Delete Coupon",
    "description": "Permanently delete a coupon and all its associated coupon codes. This action is irreversible. Note: Shopify-originated c...",
    "requiredScopes": ["coupons:write"]
  }, {
    "id": "klaviyo_list_coupon_codes",
    "label": "List Coupon Codes",
    "description": "List coupon codes filtered by coupon ID or profile ID. A filter specifying coupon.id or profile.id is required.",
    "requiredScopes": ["coupon-codes:read"]
  }, {
    "id": "klaviyo_create_coupon_code",
    "label": "Create Coupon Code",
    "description": "Create a single unique coupon code and associate it with an existing coupon. Use bulk_create_coupon_codes for creating m...",
    "requiredScopes": ["coupon-codes:write"]
  }, {
    "id": "klaviyo_get_coupon_code",
    "label": "Get Coupon Code",
    "description": "Retrieve full details for a specific coupon code by its unique ID, including its status, unique code value, and expirati...",
    "requiredScopes": ["coupon-codes:read"]
  }, {
    "id": "klaviyo_update_coupon_code",
    "label": "Update Coupon Code",
    "description": "Update the status or expiration date of an existing coupon code. Useful for manually marking codes as used or extending...",
    "requiredScopes": ["coupon-codes:write"]
  }, {
    "id": "klaviyo_delete_coupon_code",
    "label": "Delete Coupon Code",
    "description": "Permanently delete a single coupon code by its ID. This action is irreversible.",
    "requiredScopes": ["coupon-codes:write"]
  }, {
    "id": "klaviyo_bulk_create_coupon_codes",
    "label": "Bulk Create Coupon Codes",
    "description": "Create up to 1000 coupon codes in a single bulk job, associating each with an existing coupon.",
    "requiredScopes": ["coupon-codes:write"]
  }, {
    "id": "klaviyo_list_events",
    "label": "List Events",
    "description": "List Klaviyo events (customer activity records) with optional filtering by metric, profile, or date range.",
    "requiredScopes": ["events:read"]
  }, {
    "id": "klaviyo_create_event",
    "label": "Create Event",
    "description": "Track a server-side customer activity event for a profile, such as a purchase, page view, or custom business action.",
    "requiredScopes": ["events:write"]
  }, {
    "id": "klaviyo_get_event",
    "label": "Get Event",
    "description": "Retrieve complete details for a specific event by its unique ID, including all event properties and optional metric and...",
    "requiredScopes": ["events:read"]
  }, {
    "id": "klaviyo_bulk_create_events",
    "label": "Bulk Create Events",
    "description": "Efficiently ingest up to 1000 events in a single asynchronous bulk job, grouped by profile for high-volume tracking scen...",
    "requiredScopes": ["events:write"]
  }, {
    "id": "klaviyo_list_flows",
    "label": "List Flows",
    "description": "List all Klaviyo automation flows with optional filtering by name, status, trigger type, and date, plus pagination and s...",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_get_flow",
    "label": "Get Flow",
    "description": "Retrieve the full configuration of a specific Klaviyo flow by its unique ID, including trigger definition and optional f...",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_get_flow_action",
    "label": "Get Flow Action",
    "description": "Retrieve detailed configuration for a single flow action step by its unique ID, including its type, branching links, and...",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_get_flow_message",
    "label": "Get Flow Message",
    "description": "Retrieve the content and configuration of a specific flow message by its ID, including channel-specific content and temp...",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_get_actions_for_flow",
    "label": "List Flow Actions For Flow",
    "description": "List all action steps for a specific flow with pagination, filtering by action type or status, and sorting.",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_get_tags_for_flow",
    "label": "Get Tags For Flow",
    "description": "Retrieve all tags associated with a specific flow for organizational and categorization purposes.",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_get_flow_action_messages",
    "label": "Get Flow Action Messages",
    "description": "List all message variants associated with a specific flow action step, with pagination, filtering, and sorting options.",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_create_flow",
    "label": "Create Flow",
    "description": "Create a new Klaviyo automation flow with a trigger, chained actions, and optional profile filters. Use this to programm...",
    "requiredScopes": ["flows:write"]
  }, {
    "id": "klaviyo_delete_flow",
    "label": "Delete Flow",
    "description": "Permanently delete a flow and all its actions by flow ID. Use this to remove test flows or decommission automation workf...",
    "requiredScopes": ["flows:write"]
  }, {
    "id": "klaviyo_update_flow_action",
    "label": "Update Flow Action",
    "description": "Update a single action within a flow — change email subject lines, SMS body text, delay durations, split conditions, or...",
    "requiredScopes": ["flows:write"]
  }, {
    "id": "klaviyo_list_forms",
    "label": "List Forms",
    "description": "List all signup forms and pop-ups in the account with filtering, sorting, and cursor-based pagination up to 100 results...",
    "requiredScopes": ["forms:read"]
  }, {
    "id": "klaviyo_get_form",
    "label": "Get Form",
    "description": "Retrieve the full configuration and version history for a specific Klaviyo form by its unique ID.",
    "requiredScopes": ["forms:read"]
  }, {
    "id": "klaviyo_create_form",
    "label": "Create Form",
    "description": "Create a new Klaviyo form — popup, flyout, embed, banner, or full screen. Use this to programmatically deploy signup for...",
    "requiredScopes": ["forms:write"]
  }, {
    "id": "klaviyo_delete_form",
    "label": "Delete Form",
    "description": "Permanently delete a form by its ID. Use this to remove test forms or decommission form experiences. This action cannot...",
    "requiredScopes": ["forms:write"]
  }, {
    "id": "klaviyo_list_images",
    "label": "List Images",
    "description": "List all images in the Klaviyo asset library with filtering by name, format, size, or visibility, plus sorting and pagin...",
    "requiredScopes": ["images:read"]
  }, {
    "id": "klaviyo_upload_image_from_url",
    "label": "Upload Image From URL",
    "description": "Import an image into the Klaviyo asset library from a public URL or a base64-encoded data URI.",
    "requiredScopes": ["images:write"]
  }, {
    "id": "klaviyo_get_image",
    "label": "Get Image",
    "description": "Retrieve complete metadata for a specific image in the Klaviyo asset library by its unique ID.",
    "requiredScopes": ["images:read"]
  }, {
    "id": "klaviyo_update_image",
    "label": "Update Image",
    "description": "Update the name or visibility (hidden status) of an existing image in the Klaviyo asset library.",
    "requiredScopes": ["images:write"]
  }, {
    "id": "klaviyo_list_lists",
    "label": "List Lists",
    "description": "List all subscriber lists in the account with filtering by name or timestamps, sorting, and cursor-based pagination up t...",
    "requiredScopes": ["lists:read"]
  }, {
    "id": "klaviyo_create_list",
    "label": "Create List",
    "description": "Create a new subscriber list with a specified name and opt-in process (single or double opt-in) for managing profile sub...",
    "requiredScopes": ["lists:write"]
  }, {
    "id": "klaviyo_get_list",
    "label": "Get List",
    "description": "Retrieve the full details of a specific subscriber list by its unique ID, with optional profile count, tags, and flow tr...",
    "requiredScopes": ["lists:read"]
  }, {
    "id": "klaviyo_update_list",
    "label": "Update List",
    "description": "Update the name or opt-in process (single vs double opt-in) of an existing subscriber list using PATCH semantics.",
    "requiredScopes": ["lists:write"]
  }, {
    "id": "klaviyo_delete_list",
    "label": "Delete List",
    "description": "Permanently delete a subscriber list from the account - this removes the list definition but does not delete the profile...",
    "requiredScopes": ["lists:write"]
  }, {
    "id": "klaviyo_get_tags_for_list",
    "label": "Get Tags For List",
    "description": "Retrieve all tags that have been applied to a specific subscriber list, returning full tag objects including their names...",
    "requiredScopes": ["lists:read", "tags:read"]
  }, {
    "id": "klaviyo_get_profiles_for_list",
    "label": "Get Profiles For List",
    "description": "Retrieve all profile members of a subscriber list with filtering, sorting by join date, and cursor-based pagination up t...",
    "requiredScopes": ["lists:read", "profiles:read"]
  }, {
    "id": "klaviyo_add_profiles_to_list",
    "label": "Add Profiles To List",
    "description": "Add one or more existing profiles to a subscriber list by their profile IDs, up to 1000 profiles per call.",
    "requiredScopes": ["profiles:write", "lists:write"]
  }, {
    "id": "klaviyo_remove_profiles_from_list",
    "label": "Remove Profiles From List",
    "description": "Remove one or more profiles from a subscriber list by their profile IDs, up to 1000 per call, without affecting their su...",
    "requiredScopes": ["lists:write", "profiles:write"]
  }, {
    "id": "klaviyo_get_flows_triggered_by_list",
    "label": "Get Flows Triggered By List",
    "description": "Retrieve all automation flows that use a specific subscriber list as their trigger, useful for understanding dependencie...",
    "requiredScopes": ["flows:read", "lists:read"]
  }, {
    "id": "klaviyo_list_metrics",
    "label": "List Metrics",
    "description": "List all event metric types tracked in the Klaviyo account, including built-in and integration-specific metrics, up to 2...",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_get_metric",
    "label": "Get Metric",
    "description": "Retrieve complete details for a specific event metric type by its unique ID, including integration source and optional f...",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_query_metric_aggregate",
    "label": "Query Metric Aggregates",
    "description": "Query aggregated event data for a metric over a date range, with grouping by time intervals, campaign, flow, channel, or...",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_get_metric_property",
    "label": "Get Metric Property",
    "description": "Retrieve the definition and inferred data type of a specific metric property, with optional sample values for reference.",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_get_flows_triggered_by_metric",
    "label": "Get Flows Triggered By Metric",
    "description": "Retrieve all automation flows that use a specific metric as their entry trigger event.",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_list_custom_metrics",
    "label": "List Custom Metrics",
    "description": "List all custom composite metrics in the account that combine multiple underlying metrics into a single unified reportin...",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_create_custom_metric",
    "label": "Create Custom Metric",
    "description": "Create a new custom composite metric that aggregates multiple base metrics into a single unified metric for attribution...",
    "requiredScopes": ["metrics:write"]
  }, {
    "id": "klaviyo_get_custom_metric",
    "label": "Get Custom Metric",
    "description": "Retrieve the full definition and composition details for a specific custom composite metric by its unique ID.",
    "requiredScopes": ["metrics:read"]
  }, {
    "id": "klaviyo_update_custom_metric",
    "label": "Update Custom Metric",
    "description": "Update the name or definition of an existing custom composite metric using PATCH semantics.",
    "requiredScopes": ["metrics:write"]
  }, {
    "id": "klaviyo_delete_custom_metric",
    "label": "Delete Custom Metric",
    "description": "Permanently delete a custom composite metric from the account by its unique ID.",
    "requiredScopes": ["metrics:write"]
  }, {
    "id": "klaviyo_list_profiles",
    "label": "List Profiles",
    "description": "List all customer profiles in the account with rich filtering, sorting, subscription and predictive analytics data, up t...",
    "requiredScopes": ["profiles:read"]
  }, {
    "id": "klaviyo_get_profile",
    "label": "Get Profile",
    "description": "Retrieve the complete data for a specific customer profile by its Klaviyo ID, including optional subscription consent, l...",
    "requiredScopes": ["profiles:read"]
  }, {
    "id": "klaviyo_create_profile",
    "label": "Create Profile",
    "description": "Create a new customer profile with contact details, location, and custom properties; at least one of email, phone_number...",
    "requiredScopes": ["profiles:write"]
  }, {
    "id": "klaviyo_update_profile",
    "label": "Update Profile",
    "description": "Update an existing customer profile's contact details, location, or custom properties using PATCH semantics, with suppor...",
    "requiredScopes": ["profiles:write"]
  }, {
    "id": "klaviyo_get_lists_for_profile",
    "label": "Get Lists For Profile",
    "description": "Retrieve all subscriber lists that a specific profile is a member of, returning full list objects with name, opt-in proc...",
    "requiredScopes": ["profiles:read"]
  }, {
    "id": "klaviyo_get_segments_for_profile",
    "label": "Get Segments For Profile",
    "description": "Retrieve all dynamic and static segments that a specific profile currently qualifies for, returning full segment objects...",
    "requiredScopes": ["lists:read", "profiles:read"]
  }, {
    "id": "klaviyo_merge_profiles",
    "label": "Merge Profiles",
    "description": "Permanently merge one or more source profiles into a destination profile, consolidating their event history, list member...",
    "requiredScopes": ["profiles:read"]
  }, {
    "id": "klaviyo_bulk_import_profiles",
    "label": "Bulk Import Profiles",
    "description": "Submit an asynchronous bulk import job to create or update up to 10,000 profiles in a single request, with optional list...",
    "requiredScopes": ["profiles:write"]
  }, {
    "id": "klaviyo_get_list_for_bulk_import_profiles_job",
    "label": "Get List For Bulk Import Profiles Job",
    "description": "Retrieve the subscriber list(s) that profiles were added to during a specific bulk profile import job, useful for verify...",
    "requiredScopes": ["lists:read"]
  }, {
    "id": "klaviyo_get_profiles_for_bulk_import_profiles_job",
    "label": "Get Profiles For Bulk Import Profiles Job",
    "description": "Retrieve all profiles that were successfully created or updated by a completed bulk profile import job, with pagination...",
    "requiredScopes": ["lists:read"]
  }, {
    "id": "klaviyo_request_profile_deletion",
    "label": "Request Profile Deletion",
    "description": "Submit a GDPR/CCPA-compliant data deletion request for a profile identified by email, phone number, or Klaviyo profile I...",
    "requiredScopes": ["data-privacy:write"]
  }, {
    "id": "klaviyo_query_campaign_values",
    "label": "Query Campaign Values",
    "description": "Generate a campaign performance report with aggregate statistics (opens, clicks, revenue, conversions) for a given timef...",
    "requiredScopes": ["campaigns:read", "flows:read", "forms:read", "segments:read"]
  }, {
    "id": "klaviyo_query_flow_values",
    "label": "Query Flow Values",
    "description": "Generate a flow performance report with aggregate statistics (opens, clicks, revenue, conversions) broken down by flow,...",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_query_flow_series",
    "label": "Query Flow Series",
    "description": "Generate a time-series flow performance report with statistics aggregated into daily, weekly, monthly, or hourly interva...",
    "requiredScopes": ["flows:read"]
  }, {
    "id": "klaviyo_query_segment_values",
    "label": "Query Segment Values",
    "description": "Generate a segment membership report showing how many profiles were added, removed, or are currently in a segment over a...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_query_segment_series",
    "label": "Query Segment Series",
    "description": "Generate a time-series segment membership report with statistics aggregated into daily, weekly, monthly, or hourly inter...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_list_segments",
    "label": "List Segments",
    "description": "List all segments in the account with filtering by name, status, or timestamps, sorting, and cursor-based pagination, in...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_create_segment",
    "label": "Create Segment",
    "description": "Create a new segment with complex condition groups",
    "requiredScopes": ["segments:write"]
  }, {
    "id": "klaviyo_get_segment",
    "label": "Get Segment",
    "description": "Retrieve the full details of a specific segment by its unique ID, including its condition definition, active status, and...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_update_segment",
    "label": "Update Segment",
    "description": "Update an existing segment with new properties or definition",
    "requiredScopes": ["segments:write"]
  }, {
    "id": "klaviyo_delete_segment",
    "label": "Delete Segment",
    "description": "Permanently delete a segment from the account by its unique ID - this removes the segment definition but does not delete...",
    "requiredScopes": ["segments:write"]
  }, {
    "id": "klaviyo_get_tags_for_segment",
    "label": "Get Tags For Segment",
    "description": "Retrieve all tags applied to a specific segment, returning full tag objects with their names for auditing and UI display...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_get_profiles_for_segment",
    "label": "Get Profiles For Segment",
    "description": "Retrieve all profiles currently matching a segment's conditions, with filtering by contact details or join date, sorting...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_get_flows_triggered_by_segment",
    "label": "Get Flows Triggered By Segment",
    "description": "Retrieve all automation flows that use a specific segment as their trigger, useful for understanding dependencies before...",
    "requiredScopes": ["segments:read"]
  }, {
    "id": "klaviyo_list_tags",
    "label": "List Tags",
    "description": "List all tags in the account with cursor-based pagination, name filtering, and optional tag group inclusion, up to 50 re...",
    "requiredScopes": ["tags:read"]
  }, {
    "id": "klaviyo_create_tag",
    "label": "Create Tag",
    "description": "Create a new tag, optionally associating it with a specific tag group, or it defaults to the account's default tag group...",
    "requiredScopes": ["tags:write"]
  }, {
    "id": "klaviyo_get_tag",
    "label": "Get Tag",
    "description": "Retrieve complete details for a specific tag by its unique ID, including optional tag group relationship.",
    "requiredScopes": ["tags:read"]
  }, {
    "id": "klaviyo_update_tag",
    "label": "Update Tag",
    "description": "Update the name of an existing tag by its unique ID using PATCH semantics.",
    "requiredScopes": ["tags:write"]
  }, {
    "id": "klaviyo_delete_tag",
    "label": "Delete Tag",
    "description": "Permanently delete a tag and automatically remove all its associations with campaigns, flows, lists, and segments.",
    "requiredScopes": ["tags:write"]
  }, {
    "id": "klaviyo_get_flow_ids_for_tag",
    "label": "Get Flow IDs For Tag",
    "description": "Retrieve the IDs of all automation flows that are associated with a specific tag.",
    "requiredScopes": ["flows:read", "tags:read"]
  }, {
    "id": "klaviyo_tag_flows",
    "label": "Tag Flows",
    "description": "Apply a tag to one or more automation flows to organize and categorize them in the Klaviyo UI.",
    "requiredScopes": ["flows:write", "tags:write"]
  }, {
    "id": "klaviyo_get_campaign_ids_for_tag",
    "label": "Get Campaign IDs For Tag",
    "description": "Retrieve the IDs of all campaigns that are associated with a specific tag.",
    "requiredScopes": ["campaigns:read", "tags:read"]
  }, {
    "id": "klaviyo_tag_campaigns",
    "label": "Tag Campaigns",
    "description": "Apply a tag to one or more campaigns to organize and categorize them in the Klaviyo UI.",
    "requiredScopes": ["campaigns:write", "tags:write"]
  }, {
    "id": "klaviyo_get_list_ids_for_tag",
    "label": "Get List IDs For Tag",
    "description": "Retrieve the IDs of all subscriber lists that are associated with a specific tag.",
    "requiredScopes": ["lists:read", "tags:read"]
  }, {
    "id": "klaviyo_tag_lists",
    "label": "Tag Lists",
    "description": "Apply a tag to one or more subscriber lists to organize and categorize them in the Klaviyo UI.",
    "requiredScopes": ["lists:write", "tags:write"]
  }, {
    "id": "klaviyo_get_segment_ids_for_tag",
    "label": "Get Segment IDs For Tag",
    "description": "Retrieve the IDs of all segments that are associated with a specific tag.",
    "requiredScopes": ["segments:read", "tags:read"]
  }, {
    "id": "klaviyo_tag_segments",
    "label": "Tag Segments",
    "description": "Apply a tag to one or more audience segments to organize and categorize them in the Klaviyo UI.",
    "requiredScopes": ["segments:write", "tags:write"]
  }, {
    "id": "klaviyo_list_tag_groups",
    "label": "List Tag Groups",
    "description": "List all tag groups in the account with filtering by name, exclusivity, or default status, and cursor-based pagination u...",
    "requiredScopes": ["tags:read"]
  }, {
    "id": "klaviyo_create_tag_group",
    "label": "Create Tag Group",
    "description": "Create a new tag group to organize related tags under a shared category, with optional exclusivity enforcement across th...",
    "requiredScopes": ["tags:write"]
  }, {
    "id": "klaviyo_get_tag_group",
    "label": "Get Tag Group",
    "description": "Retrieve the full details of a specific tag group by its unique ID, including its name, exclusivity setting, and default...",
    "requiredScopes": ["tags:read"]
  }, {
    "id": "klaviyo_update_tag_group",
    "label": "Update Tag Group",
    "description": "Update the name of an existing tag group using PATCH semantics - only the name can be changed, not the exclusivity or de...",
    "requiredScopes": ["tags:write"]
  }, {
    "id": "klaviyo_delete_tag_group",
    "label": "Delete Tag Group",
    "description": "Permanently delete a tag group and all of its tags and their resource associations - the account's default tag group can...",
    "requiredScopes": ["tags:write"]
  }, {
    "id": "klaviyo_get_tags_for_tag_group",
    "label": "Get Tags For Tag Group",
    "description": "Retrieve all tags that belong to a specific tag group, returning the full tag objects including their names.",
    "requiredScopes": ["tags:read"]
  }, {
    "id": "klaviyo_list_templates",
    "label": "List Templates",
    "description": "List all email templates in the account with filtering by name or timestamps, sorting, and cursor-based pagination up to...",
    "requiredScopes": ["templates:read"]
  }, {
    "id": "klaviyo_create_template",
    "label": "Create Template",
    "description": "Create a new email template with custom HTML content or a drag-and-drop structure, for use in campaigns and automated fl...",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_get_template",
    "label": "Get Template",
    "description": "Retrieve the full HTML content and metadata for a specific email template by its unique ID.",
    "requiredScopes": ["templates:read"]
  }, {
    "id": "klaviyo_update_template",
    "label": "Update Template",
    "description": "Update the HTML content, plaintext version, AMP version, or name of an existing email template using PATCH semantics - n...",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_delete_template",
    "label": "Delete Template",
    "description": "Permanently delete an email template from the account by its unique ID - this action cannot be undone.",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_render_template",
    "label": "Render Template",
    "description": "Render an email template with sample profile context data to preview the final HTML, plaintext, and AMP output before se...",
    "requiredScopes": ["templates:read"]
  }, {
    "id": "klaviyo_clone_template",
    "label": "Clone Template",
    "description": "Create a duplicate copy of an existing email template with an optional new name, useful for creating variations without...",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_list_universal_content",
    "label": "List Universal Content",
    "description": "List all reusable universal content blocks in the account with filtering by name, content type, or timestamps, sorting,...",
    "requiredScopes": ["templates:read"]
  }, {
    "id": "klaviyo_create_universal_content",
    "label": "Create Universal Content",
    "description": "Create a new reusable universal content block (button, image, text, HTML, spacer, horizontal rule, or drop shadow) that...",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_get_universal_content",
    "label": "Get Universal Content",
    "description": "Retrieve the full definition and metadata of a specific universal content block by its unique ID, including block type,...",
    "requiredScopes": ["templates:read"]
  }, {
    "id": "klaviyo_update_universal_content",
    "label": "Update Universal Content",
    "description": "Update the name or block definition of an existing universal content block using PATCH semantics - changes propagate to...",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_delete_universal_content",
    "label": "Delete Universal Content",
    "description": "Permanently delete a universal content block from the account - any templates that embed this block will lose the refere...",
    "requiredScopes": ["templates:write"]
  }, {
    "id": "klaviyo_list_webhooks",
    "label": "List Webhooks",
    "description": "List all webhook subscriptions configured in the account, with optional inclusion of their subscribed topic definitions.",
    "requiredScopes": ["webhooks:read"]
  }, {
    "id": "klaviyo_get_webhook",
    "label": "Get Webhook",
    "description": "Retrieve the full configuration details of a specific webhook subscription by its unique ID, including endpoint URL, ena...",
    "requiredScopes": ["webhooks:read"]
  }, {
    "id": "klaviyo_create_webhook",
    "label": "Create Webhook",
    "description": "Create a new webhook subscription with an HTTPS endpoint URL, signing secret, and one or more event topic subscriptions...",
    "requiredScopes": ["webhooks:write"]
  }, {
    "id": "klaviyo_update_webhook",
    "label": "Update Webhook",
    "description": "Update a webhook's name, endpoint URL, signing secret, enabled status, or topic subscriptions using PATCH semantics - us...",
    "requiredScopes": ["webhooks:write"]
  }, {
    "id": "klaviyo_delete_webhook",
    "label": "Delete Webhook",
    "description": "Permanently delete a webhook subscription from the account, stopping all event notifications to that endpoint.",
    "requiredScopes": ["webhooks:write"]
  }, {
    "id": "klaviyo_list_webhook_topics",
    "label": "List Webhook Topics",
    "description": "Retrieve all available webhook event topics that can be subscribed to, returning topic IDs and descriptions for use when...",
    "requiredScopes": ["webhooks:read"]
  }, {
    "id": "klaviyo_get_webhook_topic",
    "label": "Get Webhook Topic",
    "description": "Retrieve the full details of a specific webhook topic by its ID, including the event schema, payload structure, and desc...",
    "requiredScopes": ["webhooks:read"]
  }],
  "releaseStage": "preview",
  "categories": ["marketing"],
  "scopeDefinitions": [{
    "name": "accounts:read",
    "description": "View account information"
  }, {
    "name": "campaigns:read",
    "description": "View campaigns and campaign messages"
  }, {
    "name": "campaigns:write",
    "description": "Create, update, and delete campaigns and campaign messages"
  }, {
    "name": "catalogs:read",
    "description": "View catalog items, categories, and variants"
  }, {
    "name": "catalogs:write",
    "description": "Create, update, and delete catalog items, categories, and variants"
  }, {
    "name": "coupon-codes:read",
    "description": "View coupon codes"
  }, {
    "name": "coupon-codes:write",
    "description": "Create, update, and delete coupon codes"
  }, {
    "name": "coupons:read",
    "description": "View coupons"
  }, {
    "name": "coupons:write",
    "description": "Create, update, and delete coupons"
  }, {
    "name": "data-privacy:write",
    "description": "Submit data privacy requests including profile deletion"
  }, {
    "name": "events:read",
    "description": "View events and event data"
  }, {
    "name": "events:write",
    "description": "Create and bulk create events"
  }, {
    "name": "flows:read",
    "description": "View flows, flow actions, and flow messages"
  }, {
    "name": "flows:write",
    "description": "Create, update, and delete flows"
  }, {
    "name": "forms:read",
    "description": "View forms and form versions"
  }, {
    "name": "forms:write",
    "description": "Create, update, and delete forms",
    "includes": ["forms:read"]
  }, {
    "name": "images:read",
    "description": "View images"
  }, {
    "name": "images:write",
    "description": "Upload and update images"
  }, {
    "name": "lists:read",
    "description": "View lists and list memberships"
  }, {
    "name": "lists:write",
    "description": "Create, update, delete lists and manage list memberships"
  }, {
    "name": "metrics:read",
    "description": "View metrics and metric data"
  }, {
    "name": "metrics:write",
    "description": "Create, update, and delete custom metrics"
  }, {
    "name": "profiles:read",
    "description": "View profile data and profile relationships"
  }, {
    "name": "profiles:write",
    "description": "Create, update, merge, and delete profiles"
  }, {
    "name": "segments:read",
    "description": "View segments and segment memberships"
  }, {
    "name": "segments:write",
    "description": "Create, update, and delete segments"
  }, {
    "name": "tags:read",
    "description": "View tags and tag groups"
  }, {
    "name": "tags:write",
    "description": "Create, update, delete tags and tag groups and manage tag relationships"
  }, {
    "name": "templates:read",
    "description": "View email and SMS templates"
  }, {
    "name": "templates:write",
    "description": "Create, update, delete, render, and clone templates"
  }, {
    "name": "webhooks:read",
    "description": "View webhooks and webhook topics"
  }, {
    "name": "webhooks:write",
    "description": "Create, update, and delete webhooks"
  }]
};

<ConnectorPage connector={connector} />