What is fullstory-getting-started?

Ideal for Web Development Agents implementing user session analytics and debugging. fullstory-getting-started is a skill that provides a guide for implementing Fullstory Browser API v2, covering initial setup and snippet installation for web application development.

How do I install fullstory-getting-started?

Run the command: npx killer-skills add rcmaples/btx/fullstory-getting-started. It works with Cursor, Windsurf, VS Code, Claude Code, and 15+ other IDEs.

What are the use cases for fullstory-getting-started?

Key use cases include: Implementing session replay analytics, Configuring Browser API v2 initialization, Debugging web application user behavior.

Which IDEs are compatible with fullstory-getting-started?

This skill is compatible with Cursor, Windsurf, VS Code, Claude Code, GitHub Copilot, JetBrains, Cline, Roo Code, and many more. Use the Killer-Skills CLI for universal one-command installation.

Are there any limitations for fullstory-getting-started?

Requires Fullstory API access. Browser-specific implementation only. Subject to API rate limits and changes.

Fullstory Browser API v2: Getting Started Guide

Name: fullstory-getting-started
Availability: InStock
Rating: 3.1 (1 reviews)
Author: rcmaples

📋 Version Note: This guide covers Fullstory Browser API v2. Always verify API syntax against the official documentation as the API may evolve. Rate limits, parameters, and features are subject to change.

Overview

This guide provides everything you need to implement Fullstory's Browser API v2 in your web application. It covers:

Initial Setup: Snippet installation and configuration
API Landscape: Understanding all available APIs
Implementation Order: What to implement first
Decision Framework: Choosing the right API for your data
Privacy Considerations: What to capture, mask, or exclude
Industry-Specific Guidance: Best practices for your vertical
Skill Navigation: Finding the right detailed guide

Complete Skill Inventory

Core API Skills

Skill	Purpose	Use When
`fullstory-identify-users`	Link sessions to users	Implementing login flow
`fullstory-anonymize-users`	End identified sessions	Implementing logout flow
`fullstory-user-properties`	Set user attributes	Adding segmentation data
`fullstory-page-properties`	Set page context	SPA navigation, page data
`fullstory-element-properties`	Capture interaction context	Product grids, lists
`fullstory-analytics-events`	Track discrete actions	Conversions, features
`fullstory-observe-callbacks`	React to FS lifecycle	Session URL for support
`fullstory-logging`	Add logs to session	Error debugging
`fullstory-user-consent`	Control capture consent	GDPR/CCPA compliance
`fullstory-capture-control`	Pause/resume capture	Sensitive screens
`fullstory-async-methods`	Promise-based API calls	Modern async flows
`fullstory-privacy-controls`	Mask/exclude elements	PII protection

Strategy & Meta Skills

Skill	Purpose	Use When
`fullstory-privacy-strategy`	Data privacy decisions	Planning implementation
`universal-data-scoping-and-decoration`	Where to put data	Deciding scope

Industry-Specific Skills

Skill	Industry	Key Considerations
`fullstory-banking`	Banking & Financial	PCI, GLBA, transaction masking
`fullstory-ecommerce`	E-commerce & Retail	Conversion funnels, product data
`fullstory-gaming`	Gaming	Responsible gaming, KYC
`fullstory-healthcare`	Healthcare	HIPAA, PHI exclusion
`fullstory-saas`	B2B SaaS	Feature adoption, churn
`fullstory-travel`	Travel & Hospitality	Booking funnels, PCI
`fullstory-media-entertainment`	Media & Streaming	Engagement, subscriptions

Industry Comparison at a Glance

Different industries have vastly different requirements for Fullstory implementation. This table summarizes the key differences:

Privacy Defaults by Industry

Industry	Default Privacy Mode	Financial Data	User Content	Conversion Tracking	Primary Concern
Banking	Exclude	Exclude (ranges only)	Exclude	Limited	Regulatory (PCI, GLBA)
E-commerce	Unmask	Capture (orders)	Mostly capture	Rich	Conversion optimization
Gaming	Mixed	Exclude (ranges only)	Exclude	Careful	Responsible gaming
Healthcare	Exclude	Exclude	Exclude	Very limited	HIPAA compliance
SaaS	Unmask	Usually OK	Mask/Consider	Rich	Feature adoption
Travel	Unmask	Capture (bookings)	Mask	Rich	Booking optimization
Media	Unmask	N/A	Capture	Rich	Engagement metrics

What to Capture by Industry

Data Type	Banking	E-commerce	Gaming	Healthcare	SaaS	Travel	Media
User names	❌	⚠️ Mask	⚠️ Mask	❌	⚠️ Mask	⚠️ Mask	⚠️ Mask
Email	❌	⚠️ Hash	⚠️ Hash	❌	⚠️ Consider	⚠️ Mask	⚠️ Consider
Product/content names	N/A	✅	✅ Events/games	N/A	✅ Features	✅	✅
Prices/amounts	❌ Ranges	✅	❌ Ranges	❌	✅	✅	✅ Sub prices
Account balance	❌	N/A	❌	N/A	N/A	N/A	N/A
Transaction details	❌	✅ Order data	❌	❌	✅ Usage	✅ Booking	✅ Viewing
Search queries	⚠️	✅	⚠️	❌	✅	✅	✅
Payment cards	❌	❌	❌	❌	❌	❌	❌
Government IDs	❌	❌	❌	❌	❌	❌	❌

Legend: ✅ = Capture, ⚠️ = Consider/Mask, ❌ = Exclude

Key Regulatory Requirements

Industry	Primary Regulations	Fullstory Requirements
Banking	PCI DSS, GLBA, SOX	BAA not typically needed; exclude all financial data
E-commerce	PCI DSS, CCPA, GDPR	Exclude payment fields; consent for EU
Gaming	Gaming licenses, AML/KYC	Never analyze gaming patterns; exclude amounts
Healthcare	HIPAA, HITECH	BAA required; exclude ALL PHI; masking insufficient
SaaS	SOC 2, GDPR	Enterprise privacy options; consent for EU
Travel	PCI DSS, GDPR	Exclude passport/ID numbers; payment exclusion
Media	COPPA, GDPR	Never track children's profiles; consent

I. The Fullstory API Ecosystem

Complete API Reference

API	Method	Purpose	Skill Document
Identity	`FS('setIdentity', { uid, properties })`	Identify known users	`fullstory-identify-users`
Anonymize	`FS('setIdentity', { anonymous: true })`	End identified session	`fullstory-anonymize-users`
User Properties	`FS('setProperties', { type: 'user', ... })`	Update user attributes	`fullstory-user-properties`
Page Properties	`FS('setProperties', { type: 'page', ... })`	Set page context	`fullstory-page-properties`
Element Properties	`data-fs-*` attributes	Capture interaction context	`fullstory-element-properties`
Events	`FS('trackEvent', { name, properties })`	Track discrete actions	`fullstory-analytics-events`
Observers	`FS('observe', { type, callback })`	React to FS lifecycle	`fullstory-observe-callbacks`
Logging	`FS('log', { level, msg })`	Add logs to session	`fullstory-logging`
Consent	`FS('setIdentity', { consent: bool })`	Control capture consent	`fullstory-user-consent`
Capture Control	`FS('shutdown')` / `FS('restart')`	Pause/resume capture	`fullstory-capture-control`
Async Methods	`FS('*Async')` variants	Promise-based API calls	`fullstory-async-methods`

API Categories

┌─────────────────────────────────────────────────────────────────────┐
│                        FULLSTORY BROWSER API v2                      │
├─────────────────────────────────────────────────────────────────────┤
│  IDENTITY & USER                                                     │
│  ├── setIdentity (uid)        - Identify users                      │
│  ├── setIdentity (anonymous)  - Anonymize users                     │
│  ├── setIdentity (consent)    - Manage consent                      │
│  └── setProperties (user)     - Update user attributes              │
├─────────────────────────────────────────────────────────────────────┤
│  CONTEXT & PROPERTIES                                                │
│  ├── setProperties (page)     - Page-level context                  │
│  └── Element Properties       - Interaction-level context           │
├─────────────────────────────────────────────────────────────────────┤
│  EVENTS & ACTIONS                                                    │
│  └── trackEvent               - Discrete business events            │
├─────────────────────────────────────────────────────────────────────┤
│  PRIVACY & CONTROL                                                   │
│  ├── fs-exclude / fs-mask     - Element privacy classes             │
│  ├── shutdown / restart       - Capture control                     │
│  └── consent                  - User consent management             │
├─────────────────────────────────────────────────────────────────────┤
│  LIFECYCLE & UTILITIES                                               │
│  ├── observe                  - Lifecycle callbacks                 │
│  ├── log                      - Session logging                     │
│  ├── getSession               - Get session URL                     │
│  └── *Async variants          - Promise-based methods               │
└─────────────────────────────────────────────────────────────────────┘

II. Snippet Installation

Basic Snippet (v2)

Add this snippet to your HTML <head>:

html
1<script>
2  window['_fs_host'] = 'fullstory.com'
3  window['_fs_script'] = 'edge.fullstory.com/s/fs.js'
4  window['_fs_org'] = 'YOUR_ORG_ID'
5  window['_fs_namespace'] = 'FS'
6
7  ;(function (m, n, e, t, l, o, g, y) {
8    if (e in m) {
9      if (m.console && m.console.log) {
10        m.console.log('Fullstory namespace conflict. Please set window["_fs_namespace"].')
11      }
12      return
13    }
14    g = m[e] = function (a, b, s) {
15      g.q ? g.q.push([a, b, s]) : g._api(a, b, s)
16    }
17    g.q = []
18    o = n.createElement(t)
19    o.async = 1
20    o.crossOrigin = 'anonymous'
21    o.src = 'https://' + _fs_script
22    y = n.getElementsByTagName(t)[0]
23    y.parentNode.insertBefore(o, y)
24    g.identify = function (i, v, s) {
25      g(l, {uid: i}, s)
26      if (v) g(l, v, s)
27    }
28    g.setUserVars = function (v, s) {
29      g(l, v, s)
30    }
31    g.event = function (i, v, s) {
32      g('event', {n: i, p: v}, s)
33    }
34    g.anonymize = function () {
35      g.identify(!!0)
36    }
37    g.shutdown = function () {
38      g('rec', !1)
39    }
40    g.restart = function () {
41      g('rec', !0)
42    }
43    g.log = function (a, b) {
44      g('log', [a, b])
45    }
46    g.consent = function (a) {
47      g('consent', !arguments.length || a)
48    }
49    g.identifyAccount = function (i, v) {
50      o = 'account'
51      v = v || {}
52      v.acctId = i
53      g(o, v)
54    }
55    g.clearUserCookie = function () {}
56    g.setVars = function (n, p) {
57      g('setVars', [n, p])
58    }
59    g._w = {}
60    y = 'XMLHttpRequest'
61    g._w[y] = m[y]
62    y = 'fetch'
63    g._w[y] = m[y]
64    if (m[y])
65      m[y] = function () {
66        return g._w[y].apply(this, arguments)
67      }
68    g._v = '2.0.0'
69  })(window, document, window['_fs_namespace'], 'script', 'identify')
70</script>

Configuration Options

Option	Description	Default
`_fs_org`	Your Fullstory organization ID	Required
`_fs_namespace`	Global variable name	`'FS'`
`_fs_capture_on_startup`	Start capturing immediately	`true`
`_fs_host`	Fullstory host	`'fullstory.com'`
`_fs_script`	Script location	`'edge.fullstory.com/s/fs.js'`

How Fullstory Tracks Users (First-Party Cookies)

Fullstory uses first-party cookies set on YOUR domain to track users:

Cookie	Duration	Purpose
`fs_uid`	1 year	Tracks user across sessions (the "capture cookie")
`fs_cid`	1 year	Stores consent state for the device
`fs_lua`	30 min	Last user action timestamp (session lifecycle)

Why First-Party Cookies Matter:

Aspect	First-Party (Fullstory)	Third-Party Cookies
Domain	Set on YOUR domain	Set on external domain
Browser blocking	✅ Not blocked by browsers/ad-blockers	❌ Often blocked
Cross-site tracking	❌ Cannot track across different sites	✅ Can track across web
Privacy	✅ Your data stays isolated to your site	❌ Data aggregated

Key Behaviors:

Anonymous users persist: Same fs_uid cookie = same user across sessions (until cookie expires/deleted)
Session merging: When setIdentity is called, ALL previous anonymous sessions from that cookie merge into the identified user
Anonymization resets: setIdentity({ anonymous: true }) generates a NEW fs_uid cookie, breaking the link to previous sessions

Reference: Why Fullstory uses First-Party Cookies

Private by Default Mode (Recommended for Sensitive Industries)

Fullstory offers a Private by Default capture mode that inverts the default behavior:

Mode	Default Behavior	Your Action
Standard	Everything captured (unmask is default)	Add `fs-mask` / `fs-exclude` to protect sensitive elements
Private by Default	Everything masked	Add `fs-unmask` to reveal safe content

When to Use Private by Default:

✅ Banking / Financial services
✅ Healthcare / HIPAA-regulated
✅ Enterprise SaaS with customer data
✅ Any app where "default open" is too risky

Enable via:

New accounts: Select during onboarding wizard
Existing accounts: Contact Fullstory Support

Reference: Fullstory Private by Default

Consent-Required Configuration (GDPR)

For GDPR compliance, don't capture until consent is given:

html
1<script>
2  window['_fs_capture_on_startup'] = false // Don't capture until consent
3  window['_fs_org'] = 'YOUR_ORG_ID'
4  // ... rest of snippet
5</script>

Then call when consent is granted:

javascript
1FS('setIdentity', {consent: true})

III. Implementation Order

Recommended Implementation Sequence

Phase 1: Foundation
├── 1. Install snippet
├── 2. Implement privacy controls (fs-exclude, fs-mask)
├── 3. Implement user identification (login flow)
├── 4. Implement anonymization (logout flow)
└── 5. Set up basic page properties (pageName)

Phase 2: Context
├── 6. Add user properties (plan, role, company)
├── 7. Enhance page properties (search terms, filters)
└── 8. Add element properties (product IDs, positions)

Phase 3: Events
├── 9. Implement key business events
├── 10. Add funnel tracking
└── 11. Add feature usage tracking

Phase 4: Advanced
├── 12. Set up observers for session URL
├── 13. Implement consent flows (if GDPR required)
├── 14. Add error logging
└── 15. Implement capture control (if needed)

Minimum Viable Implementation

For a basic integration, implement these APIs:

javascript
1// 1. Identify users on login
2FS('setIdentity', {
3  uid: user.id,
4  properties: {
5    displayName: user.name,
6    email: user.email,
7  },
8})
9
10// 2. Set page context
11FS('setProperties', {
12  type: 'page',
13  properties: {
14    pageName: 'Dashboard',
15  },
16})
17
18// 3. Track key events
19FS('trackEvent', {
20  name: 'Feature Used',
21  properties: {
22    featureName: 'export',
23  },
24})
25
26// 4. Anonymize on logout
27FS('setIdentity', {anonymous: true})

IV. Privacy First: Three Privacy Modes

Before capturing any data, understand the three privacy modes:

Privacy Mode Comparison

Mode	CSS Class	What Leaves Device	Events Captured	Use For
Exclude	`.fs-exclude`	❌ Nothing	❌ No	Passwords, SSN, PHI, card numbers
Mask	`.fs-mask`	⚠️ Structure only	✅ Yes	Names, emails, addresses
Unmask	`.fs-unmask`	✅ Everything	✅ Yes	Public content, products

Quick Privacy Decision

Is this data regulated (HIPAA, PCI, GLBA)?
     │
     YES → fs-exclude (nothing leaves device)
     │
     NO
     │
     ▼
Is this PII (name, email, address)?
     │
     YES → fs-mask (structure captured, text replaced)
     │
     NO
     │
     ▼
Is this public/business data?
     │
     YES → fs-unmask or default (everything captured)

Privacy by Industry Quick Reference

Industry	Default Recommendation
Healthcare	Use Private by Default mode; explicit unmask only
Banking	Exclude financial data; mask PII
Gaming	Exclude amounts; mask user info
E-commerce	Unmask products; mask checkout PII; exclude payment
SaaS	Unmask features; mask user content
Travel	Unmask search/booking; mask traveler PII; exclude IDs
Media	Unmask content; mask profiles

V. Quick Decision Guide

"Where should I put this data?"

Is this data about WHO the user is?
(plan, role, company, signup date)
     │
     YES → User Properties (setIdentity or setProperties type: 'user')
     │
     NO
     │
     ▼
Is this data the same for the entire page?
(search term, product ID on detail page, filters)
     │
     YES → Page Properties (setProperties type: 'page')
     │
     NO
     │
     ▼
Is this data specific to one element among many?
(product ID in a grid, position in list)
     │
     YES → Element Properties (data-fs-* attributes)
     │
     NO
     │
     ▼
Is this a discrete action/event?
(purchase, signup, feature used)
     │
     YES → Event (trackEvent)

Quick Reference Table

I want to...	Use this API	Skill
Link sessions to a user	`setIdentity`	`fullstory-identify-users`
Add user attributes	`setProperties(user)`	`fullstory-user-properties`
Set page context	`setProperties(page)`	`fullstory-page-properties`
Track what was clicked	Element Properties	`fullstory-element-properties`
Track a conversion	`trackEvent`	`fullstory-analytics-events`
Handle logout	`setIdentity(anonymous)`	`fullstory-anonymize-users`
Get session URL	`observe` or `getSession`	`fullstory-observe-callbacks`
Implement GDPR consent	`setIdentity(consent)`	`fullstory-user-consent`
Pause recording	`shutdown`/`restart`	`fullstory-capture-control`
Log errors to session	`log`	`fullstory-logging`
Protect sensitive data	CSS classes	`fullstory-privacy-controls`

VI. Industry-Specific Quick Start

Banking/Financial Services

javascript
1// Use internal customer ID, never SSN or account numbers
2FS('setIdentity', {uid: customer.customerId})
3
4// Exclude all financial data, use ranges if needed
5// Add fs-exclude to: balances, transactions, account numbers
6FS('trackEvent', {
7  name: 'transfer_completed',
8  properties: {
9    transfer_type: 'internal',
10    amount_range: '$100-$500', // Never exact amount
11  },
12})

→ See fullstory-banking for complete guide

E-commerce

javascript
1// Rich product tracking is valuable
2FS('setProperties', {
3  type: 'page',
4  properties: {
5    pageName: 'Product Detail',
6    productId: product.id,
7    productName: product.name,
8    price: product.price, // Prices are fine in e-commerce
9  },
10})
11
12// Track conversions with full details
13FS('trackEvent', {
14  name: 'purchase_completed',
15  properties: {
16    order_id: order.id,
17    revenue: order.total,
18    item_count: order.items.length,
19  },
20})

→ See fullstory-ecommerce for complete guide

Healthcare

javascript
1// Extremely limited capture - use anonymous sessions if possible
2FS('setIdentity', {uid: generateSessionId()}) // No linking to patient
3
4// Exclude EVERYTHING medical - masking is NOT sufficient
5// Use Private by Default mode
6// Only track: navigation, errors, page load times

→ See fullstory-healthcare for complete guide

SaaS

javascript
1// Rich user identification for feature adoption
2FS('setIdentity', {
3  uid: user.id,
4  properties: {
5    displayName: user.firstName,
6    plan: organization.plan,
7    role: user.role,
8    org_id: organization.id,
9  },
10})
11
12// Track feature usage comprehensively
13FS('trackEvent', {
14  name: 'feature_first_use',
15  properties: {
16    feature_name: 'report_builder',
17    days_since_signup: user.daysSinceSignup,
18  },
19})

→ See fullstory-saas for complete guide

VII. Common Integration Patterns

Pattern 1: React Integration

jsx
1// hooks/useFullstory.js
2import {useEffect} from 'react'
3import {useAuth} from './useAuth'
4import {useLocation} from 'react-router-dom'
5
6export function useFullstory() {
7  const {user, isAuthenticated} = useAuth()
8  const location = useLocation()
9
10  // Handle user identification
11  useEffect(() => {
12    if (isAuthenticated && user) {
13      FS('setIdentity', {
14        uid: user.id,
15        properties: {
16          displayName: user.name,
17          email: user.email,
18          plan: user.plan,
19        },
20      })
21    }
22  }, [user, isAuthenticated])
23
24  // Handle page changes
25  useEffect(() => {
26    const pageName = getPageName(location.pathname)
27    FS('setProperties', {
28      type: 'page',
29      properties: {pageName},
30    })
31  }, [location])
32
33  // Return helper functions
34  return {
35    trackEvent: (name, properties) => {
36      FS('trackEvent', {name, properties})
37    },
38    setUserProperty: (properties) => {
39      FS('setProperties', {type: 'user', properties})
40    },
41  }
42}

Pattern 2: Privacy-First Component Wrapper

jsx
1// components/PrivacyWrapper.js
2export function SensitiveData({ children, level = 'mask' }) {
3  const className = level === 'exclude' ? 'fs-exclude' : 'fs-mask';
4  return <div className={className}>{children}</div>;
5}
6
7export function PublicData({ children }) {
8  return <div className="fs-unmask">{children}</div>;
9}
10
11// Usage
12<SensitiveData level="exclude">
13  <CreditCardForm />
14</SensitiveData>
15
16<SensitiveData>
17  <UserProfile />  {/* Masked by default */}
18</SensitiveData>
19
20<PublicData>
21  <ProductGrid />  {/* Visible */}
22</PublicData>

VIII. Testing Your Integration

1. Verify Snippet Installation

Open browser console and check:

javascript
1typeof FS !== 'undefined' // Should be true
2FS('getSession') // Should return session URL

2. Check Privacy Controls

In browser DevTools:

Verify .fs-exclude classes on sensitive elements
Verify .fs-mask classes on PII fields
Watch a session replay and confirm masked/excluded content

3. Check User Identification

After login, verify in Fullstory:

Session shows user's displayName
User can be found by search
User properties appear in session details

4. Validate Events

After triggering events:

Check Events panel in Fullstory session
Verify event properties are captured correctly
Test event-based searches work

IX. Troubleshooting

Fullstory Not Loading

javascript
1if (typeof FS === 'undefined') {
2  console.error('Fullstory not loaded - check snippet installation')
3}

Common causes:

Snippet not in <head>
Wrong org ID
Ad blocker blocking script
Content Security Policy blocking

User Not Identified

javascript
1console.log('Identifying user:', user.id)
2FS('setIdentity', {uid: user.id})

Common causes:

uid is undefined or null
setIdentity called before FS loads
Identity called with wrong syntax

Privacy Not Working

Common causes:

CSS class not on element (check DevTools)
Child element needs its own class
Conflicting CSS selector rules in Settings

X. Related Skills Reference

Core Data Capture

Skill	Use For
`fullstory-identify-users`	User identification and login
`fullstory-anonymize-users`	Logout and user switching
`fullstory-user-properties`	User attributes and segmentation
`fullstory-page-properties`	Page context and Journeys
`fullstory-element-properties`	Interaction-level data
`fullstory-analytics-events`	Business events and funnels

Privacy & Control

Skill	Use For
`fullstory-privacy-controls`	Element masking and exclusion
`fullstory-privacy-strategy`	Data privacy decisions
`fullstory-user-consent`	GDPR/CCPA compliance
`fullstory-capture-control`	Pause/resume recording

Lifecycle & Utilities

Skill	Use For
`fullstory-async-methods`	Promise-based API calls
`fullstory-observe-callbacks`	Session URL and lifecycle events
`fullstory-logging`	Error and debug logging

Industry-Specific

Skill	Use For
`fullstory-banking`	Financial services implementation
`fullstory-ecommerce`	E-commerce/retail implementation
`fullstory-gaming`	Gaming/gaming implementation
`fullstory-healthcare`	Healthcare/HIPAA implementation
`fullstory-saas`	B2B SaaS implementation
`fullstory-travel`	Travel/hospitality implementation
`fullstory-media-entertainment`	Media/streaming implementation

Strategy

Skill	Use For
`universal-data-scoping-and-decoration`	Deciding where to put data

Framework Integration

Skill	Use For
`fullstory-stable-selectors`	Stable `data-*` attributes for any framework (React, Angular, Vue, etc.)

Key Takeaways for Agent

When helping developers get started with Fullstory:

Privacy first:
- Ask what industry/regulations apply
- Point to appropriate industry skill
- Default to more restrictive privacy in regulated industries
Implementation order matters:
- Start with privacy controls
- Then identification (login/logout)
- Add page properties (pageName is crucial for Journeys)
- Then events and element properties
Minimum viable integration:
- Privacy classes on sensitive elements
- setIdentity on login
- setIdentity anonymous on logout
- setProperties(page) with pageName
- A few key trackEvent calls
Industry matters:
- Healthcare: Default exclude, BAA required
- Banking: Exclude financial data, use ranges
- E-commerce: Can capture most product data
- SaaS: Rich feature tracking is valuable
Common first questions:
- "How do I link sessions to users?" → fullstory-identify-users
- "Where should I put this data?" → universal-data-scoping-and-decoration
- "How do I track conversions?" → fullstory-analytics-events
- "What should I mask vs exclude?" → fullstory-privacy-controls
Point to specific skills for detailed implementation guidance

Reference Links

Getting Started: https://developer.fullstory.com/browser/getting-started/
Privacy Controls: https://help.fullstory.com/hc/en-us/articles/360020623574
Custom Properties: https://developer.fullstory.com/browser/custom-properties/
Help Center: https://help.fullstory.com/

This getting started guide provides the foundation for implementing Fullstory Browser API v2. For detailed implementation guidance on any specific API or industry, refer to the linked skill documents.

About this Skill

Features

# Core Topics

↓ Quality Score

Agent Capability Analysis

Ideal Agent Persona

Core Value

↓ Capabilities Granted for fullstory-getting-started MCP Server

! Prerequisites & Limits

# Tags

Fullstory Browser API v2: Getting Started Guide

Overview

Complete Skill Inventory

Core API Skills

Strategy & Meta Skills

Industry-Specific Skills

Industry Comparison at a Glance

Privacy Defaults by Industry

What to Capture by Industry

Key Regulatory Requirements

I. The Fullstory API Ecosystem

Complete API Reference

API Categories

II. Snippet Installation

Basic Snippet (v2)

Configuration Options

How Fullstory Tracks Users (First-Party Cookies)

Private by Default Mode (Recommended for Sensitive Industries)

Consent-Required Configuration (GDPR)

III. Implementation Order

Recommended Implementation Sequence

Minimum Viable Implementation

IV. Privacy First: Three Privacy Modes

Privacy Mode Comparison

Quick Privacy Decision

Privacy by Industry Quick Reference

V. Quick Decision Guide

"Where should I put this data?"

Quick Reference Table

VI. Industry-Specific Quick Start

Banking/Financial Services

E-commerce

Healthcare

SaaS

VII. Common Integration Patterns

Pattern 1: React Integration

Pattern 2: Privacy-First Component Wrapper

VIII. Testing Your Integration

1. Verify Snippet Installation

2. Check Privacy Controls

3. Check User Identification

4. Validate Events

IX. Troubleshooting

Fullstory Not Loading

User Not Identified

Privacy Not Working

X. Related Skills Reference

Core Data Capture

Privacy & Control

Lifecycle & Utilities

Industry-Specific

Strategy

Framework Integration

Key Takeaways for Agent

Reference Links

Related Skills

Looking for an alternative to fullstory-getting-started or building a Categories.community AI Agent? Explore these related open-source MCP Servers.

widget-generator

chat-sdk

zustand

data-fetching