# Authentication
Source: https://docs.firstquadrant.ai/api-reference/authentication

How to authenticate your requests to the FirstQuadrant API

The FirstQuadrant API supports two types of authentication:

1. **API Keys** - For programmatic access
2. **Access Tokens** - For user authentication

## API keys

API keys are used for programmatic access to the FirstQuadrant API. They are prefixed with `fqa_` and can be generated from the web application's settings.

### Obtaining an API key

1. Log in to your FirstQuadrant account
2. Go to Settings > API Keys
3. Click "Create API Key"
4. Give your API key a name and select the required scopes
5. Copy the generated API key immediately - you won't be able to see it again

### Using API keys

Include your API key in the `Authorization` header:

```bash  theme={null}
Authorization: Bearer fqa_your_api_key
```

### API key scopes

API keys can be restricted to specific scopes using the following format:

```
urn:firstquadrant:<resource>:<action>:<permission>
```

Where:

* `<resource>` is the resource type (e.g., `user`, `organization`, `campaign`)
* `<action>` is the action type (e.g., `*` for all actions)
* `<permission>` is either `read` or `write`

Examples:

* `urn:firstquadrant:user:*:read` - Read access to user resources
* `urn:firstquadrant:organization:*:write` - Write access to organization resources
* `urn:firstquadrant:*:*:read` - Read access to all resources (sudo)

### Organization context

When using API keys, you must include the organization ID in the `FirstQuadrant-Organization-ID` header:

```bash  theme={null}
FirstQuadrant-Organization-ID: org_123
```

## Access tokens

Access tokens are used to authenticate users who are logged into the FirstQuadrant web application. They are JWT tokens that contain user information and permissions.

### Obtaining an access token

1. Log in to your FirstQuadrant account through the web application
2. Your access token will be automatically included in all API requests made through the web interface
3. For programmatic access, you can use the refresh token flow described below

### Using access tokens

Include your access token in the `Authorization` header:

```bash  theme={null}
Authorization: Bearer your_access_token
```

### Refresh token flow

1. When you first authenticate, you'll receive both an access token and a refresh token
2. Access tokens expire after 24 hours
3. To get a new access token, send a POST request to `/auth` with your refresh token:

```bash  theme={null}
curl -X POST https://api.firstquadrant.ai/auth \
  -H "Content-Type: application/json" \
  -d '{"token": "your_refresh_token"}'
```

The response will include new access and refresh tokens:

```json  theme={null}
{
  "userId": "user_123",
  "sessionId": "session_456",
  "accessToken": "new_access_token",
  "refreshToken": "new_refresh_token"
}
```

## Error responses

The API will return the following error responses for authentication issues:

### 401 Unauthorized

```json  theme={null}
{
  "code": "missing_authorization",
  "status": 401,
  "message": "You are not logged in",
  "description": "This resource is only available when you are logged in. Please use an access token or API key for authorization."
}
```

### 403 Forbidden

```json  theme={null}
{
  "code": "missing_scopes",
  "status": 403,
  "message": "Missing scopes",
  "description": "This resource is not available to you. Please ensure your access token or API key has the required scopes."
}
```

## Security best practices

1. Never share your API keys or access tokens
2. Rotate API keys regularly
3. Use the minimum required scopes for API keys
4. Store tokens securely and never commit them to version control
5. Use environment variables for storing sensitive credentials


# Best practices
Source: https://docs.firstquadrant.ai/api-reference/best-practices

Guidelines and recommendations for building robust integrations with the FirstQuadrant API

Following these best practices will help you build efficient, reliable, and maintainable integrations with the FirstQuadrant API.

## Authentication & security

### Secure credential storage

Never hardcode API keys or tokens in your source code:

```javascript  theme={null}
// ❌ Bad: Hardcoded credentials
const apiKey = "fqa_abc123def456";

// ✅ Good: Environment variables
const apiKey = process.env.FIRSTQUADRANT_API_KEY;

// ✅ Good: Secure key management service
const apiKey = await keyVault.getSecret("firstquadrant-api-key");
```

### API key rotation

Implement a rotation strategy for API keys:

1. Generate new API keys periodically
2. Update your applications with the new key
3. Revoke old keys after confirming the new key works
4. Monitor for unauthorized usage

### Minimize scope

Request only the permissions your integration needs:

```javascript  theme={null}
// ❌ Bad: Requesting all permissions
const scopes = ["urn:firstquadrant:*:*:write"];

// ✅ Good: Specific permissions only
const scopes = ["urn:firstquadrant:contact:*:read", "urn:firstquadrant:campaign:*:write"];
```

## Request optimization

### Use field selection

Only request the fields you need to reduce payload size and improve performance:

```javascript  theme={null}
// ❌ Bad: Fetching all fields when you only need a few
const response = await fetch("/v5/contacts?limit=100");

// ✅ Good: Select specific fields
const response = await fetch("/v5/contacts?select[]=id&select[]=email&select[]=firstName&limit=100");
```

### Batch operations

When possible, group operations to reduce API calls:

```javascript  theme={null}
// ❌ Bad: Individual requests for each contact
for (const email of emails) {
  await createContact({ email });
}

// ✅ Good: Process in batches
async function processBatch(contacts) {
  // Use bulk endpoints when available
  // Or process with controlled concurrency
  const batchSize = 50;
  for (let i = 0; i < contacts.length; i += batchSize) {
    const batch = contacts.slice(i, i + batchSize);
    await Promise.all(batch.map((contact) => createContact(contact)));
  }
}
```

### Implement caching

Cache frequently accessed, rarely changing data:

```javascript  theme={null}
class CachedAPI {
  constructor(ttl = 300000) {
    // 5 minutes
    this.cache = new Map();
    this.ttl = ttl;
  }

  async getOrganization(id) {
    const cacheKey = `org:${id}`;
    const cached = this.cache.get(cacheKey);

    if (cached && Date.now() < cached.expiry) {
      return cached.data;
    }

    const data = await fetchOrganization(id);
    this.cache.set(cacheKey, {
      data,
      expiry: Date.now() + this.ttl,
    });

    return data;
  }
}
```

## Error handling

### Implement comprehensive error handling

Handle all possible error scenarios:

```javascript  theme={null}
async function apiRequest(endpoint, options = {}) {
  try {
    const response = await fetch(`${API_BASE}${endpoint}`, {
      ...options,
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        "Content-Type": "application/json",
        ...options.headers,
      },
    });

    // Handle different error types
    if (!response.ok) {
      const error = await response.json();

      switch (response.status) {
        case 400:
          throw new ValidationError(error);
        case 401:
          await refreshToken();
          return apiRequest(endpoint, options); // Retry
        case 403:
          throw new PermissionError(error);
        case 404:
          throw new NotFoundError(error);
        case 429:
          await handleRateLimit(response);
          return apiRequest(endpoint, options); // Retry
        case 500:
        case 502:
        case 503:
        case 504:
          throw new ServerError(error);
        default:
          throw new APIError(error);
      }
    }

    return response.json();
  } catch (error) {
    if (error.name === "AbortError") {
      throw new TimeoutError("Request timeout");
    }
    if (error.name === "TypeError") {
      throw new NetworkError("Network error");
    }
    throw error;
  }
}
```

### Log errors with context

Include request details for debugging:

```javascript  theme={null}
function logError(error, context) {
  console.error({
    timestamp: new Date().toISOString(),
    error: {
      message: error.message,
      code: error.code,
      status: error.status,
    },
    request: {
      method: context.method,
      endpoint: context.endpoint,
      requestId: context.headers?.["X-Request-Id"],
    },
    user: context.userId,
    organization: context.organizationId,
  });
}
```

## Performance

### Implement request timeouts

Prevent hanging requests:

```javascript  theme={null}
async function fetchWithTimeout(url, options = {}, timeout = 30000) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);

  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal,
    });
    return response;
  } finally {
    clearTimeout(timeoutId);
  }
}
```

### Use pagination efficiently

Process large datasets without overwhelming your system:

```javascript  theme={null}
async function* getAllContacts(filters = {}) {
  let cursor = null;
  const pageSize = 100; // Maximum allowed

  while (true) {
    const params = new URLSearchParams({
      ...filters,
      limit: pageSize,
      ...(cursor && { startingAfter: cursor }),
    });

    const contacts = await fetch(`/v5/contacts?${params}`);

    if (contacts.length === 0) break;

    yield contacts;

    if (contacts.length < pageSize) break;
    cursor = contacts[contacts.length - 1].id;
  }
}

// Process in streams
for await (const batch of getAllContacts()) {
  await processBatch(batch);
}
```

### Implement connection pooling

Reuse connections for better performance:

```javascript  theme={null}
import { Agent } from "https";

const httpsAgent = new Agent({
  keepAlive: true,
  keepAliveMsecs: 60000,
  maxSockets: 10,
});

const response = await fetch(url, {
  agent: httpsAgent,
  // ... other options
});
```

## ID management

### Use type-prefixed IDs

Always validate ID formats:

```javascript  theme={null}
const ID_PATTERNS = {
  user: /^usr_[a-zA-Z0-9]+$/,
  organization: /^org_[a-zA-Z0-9]+$/,
  contact: /^con_[a-zA-Z0-9]+$/,
  campaign: /^cam_[a-zA-Z0-9]+$/,
  deal: /^del_[a-zA-Z0-9]+$/,
};

function validateId(id, type) {
  const pattern = ID_PATTERNS[type];
  if (!pattern || !pattern.test(id)) {
    throw new Error(`Invalid ${type} ID format: ${id}`);
  }
  return id;
}

// Usage
const contactId = validateId(inputId, "contact");
```

## Data consistency

### Handle concurrent updates

Implement optimistic locking when needed:

```javascript  theme={null}
async function updateContact(id, updates) {
  // Fetch current version
  const current = await getContact(id);

  try {
    const updated = await apiRequest(`/contacts/${id}`, {
      method: "PATCH",
      body: JSON.stringify({
        ...updates,
        expectedVersion: current.version, // If API supports versioning
      }),
    });
    return updated;
  } catch (error) {
    if (error.code === "conflict") {
      // Handle concurrent modification
      console.warn("Contact was modified by another process");
      // Retry with fresh data or merge changes
    }
    throw error;
  }
}
```

### Validate data before sending

Validate on the client side to avoid unnecessary API calls:

```javascript  theme={null}
import { z } from "zod";

const ContactSchema = z.object({
  email: z.string().email(),
  firstName: z.string().min(1).max(100),
  lastName: z.string().min(1).max(100),
  phone: z
    .string()
    .regex(/^\+[1-9]\d{1,14}$/)
    .optional(),
  customProperties: z.record(z.any()).optional(),
});

function createContact(data) {
  // Validate before API call
  const validated = ContactSchema.parse(data);

  return apiRequest("/contacts", {
    method: "POST",
    body: JSON.stringify(validated),
  });
}
```

## Monitoring & observability

### Track API usage

Monitor your integration's performance:

```javascript  theme={null}
class APIMetrics {
  constructor() {
    this.metrics = {
      requests: 0,
      errors: 0,
      latency: [],
    };
  }

  async track(fn) {
    const start = Date.now();
    this.metrics.requests++;

    try {
      const result = await fn();
      this.metrics.latency.push(Date.now() - start);
      return result;
    } catch (error) {
      this.metrics.errors++;
      throw error;
    }
  }

  getStats() {
    const latency = this.metrics.latency;
    return {
      totalRequests: this.metrics.requests,
      errorRate: this.metrics.errors / this.metrics.requests,
      avgLatency: latency.reduce((a, b) => a + b, 0) / latency.length,
      p95Latency: latency.sort()[Math.floor(latency.length * 0.95)],
    };
  }
}
```

### Include correlation IDs

Track requests across systems:

```javascript  theme={null}
import { randomUUID } from "crypto";

function createRequestHeaders(correlationId = randomUUID()) {
  return {
    Authorization: `Bearer ${API_KEY}`,
    "FirstQuadrant-Organization-ID": ORGANIZATION_ID,
    "X-Correlation-ID": correlationId,
    "User-Agent": "MyApp/1.0.0",
  };
}
```

## Integration patterns

### Implement idempotency

Make operations safe to retry:

```javascript  theme={null}
async function createCampaignIdempotent(campaign, idempotencyKey) {
  // Check if already processed
  const existing = await cache.get(`idempotent:${idempotencyKey}`);
  if (existing) return existing;

  const result = await apiRequest("/campaigns", {
    method: "POST",
    headers: {
      "Idempotency-Key": idempotencyKey,
    },
    body: JSON.stringify(campaign),
  });

  // Cache result
  await cache.set(`idempotent:${idempotencyKey}`, result, 86400000); // 24h

  return result;
}
```

### Handle webhooks securely

If implementing webhook endpoints:

```javascript  theme={null}
function verifyWebhookSignature(payload, signature, secret) {
  const hmac = crypto.createHmac("sha256", secret);
  const digest = hmac.update(payload).digest("hex");

  // Use timing-safe comparison
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(digest));
}

app.post("/webhook", (req, res) => {
  const signature = req.headers["x-webhook-signature"];

  if (!verifyWebhookSignature(req.body, signature, WEBHOOK_SECRET)) {
    return res.status(401).send("Invalid signature");
  }

  // Process webhook
  processWebhook(req.body);

  // Always respond quickly
  res.status(200).send("OK");
});
```

## Testing

### Mock API responses

Test without hitting the real API:

```javascript  theme={null}
class MockAPI {
  constructor() {
    this.responses = new Map();
  }

  setResponse(method, path, response) {
    this.responses.set(`${method}:${path}`, response);
  }

  async fetch(path, options = {}) {
    const method = options.method || "GET";
    const key = `${method}:${path}`;

    const response = this.responses.get(key);
    if (!response) {
      throw new Error(`No mock response for ${key}`);
    }

    return {
      ok: response.status >= 200 && response.status < 300,
      status: response.status,
      json: async () => response.body,
    };
  }
}

// In tests
const mockAPI = new MockAPI();
mockAPI.setResponse("GET", "/v5/contacts/con_123", {
  status: 200,
  body: { id: "con_123", email: "test@example.com" },
});
```

## Documentation

### Document your integration

Maintain clear documentation:

```javascript  theme={null}
/**
 * FirstQuadrant API Client
 *
 * @example
 * const client = new FirstQuadrantClient({
 *   apiKey: process.env.FQ_API_KEY,
 *   organizationId: process.env.FQ_ORG_ID
 * });
 *
 * const contacts = await client.contacts.list({
 *   filter: { tags: { has: 'customer' } },
 *   limit: 50
 * });
 */
class FirstQuadrantClient {
  // Implementation
}
```

## Summary

Key takeaways for building robust FirstQuadrant API integrations:

1. **Security First**: Protect credentials, validate inputs, use minimum required permissions
2. **Handle Errors Gracefully**: Implement comprehensive error handling and retry logic
3. **Optimize Performance**: Use field selection, pagination, and caching
4. **Monitor Everything**: Track metrics, log errors with context, use correlation IDs
5. **Test Thoroughly**: Mock API responses, test error scenarios, validate edge cases
6. **Document Well**: Maintain clear documentation for your integration

Following these practices will help ensure your integration is reliable, performant, and maintainable.


# Error handling
Source: https://docs.firstquadrant.ai/api-reference/errors

Understanding and handling errors in the FirstQuadrant API

The FirstQuadrant API uses conventional HTTP response codes to indicate the success or failure of an API request. This guide explains our error format and how to handle common errors.

## HTTP status codes

| Status Code | Description                                                   |
| ----------- | ------------------------------------------------------------- |
| `200`       | Success - The request completed successfully                  |
| `201`       | Created - A new resource was created successfully             |
| `204`       | No Content - The request succeeded with no response body      |
| `400`       | Bad Request - The request was invalid or malformed            |
| `401`       | Unauthorized - Authentication failed or missing               |
| `403`       | Forbidden - Valid authentication but insufficient permissions |
| `404`       | Not Found - The requested resource doesn't exist              |
| `409`       | Conflict - The request conflicts with existing data           |
| `422`       | Unprocessable Entity - Validation errors                      |
| `429`       | Too Many Requests - Rate limit exceeded                       |
| `500`       | Internal Server Error - Something went wrong on our end       |

## Error response format

All errors follow a consistent JSON structure:

```json  theme={null}
{
  "code": "validation_error",
  "status": 422,
  "message": "Validation failed",
  "description": "The request body contains invalid data.",
  "details": [
    {
      "field": "email",
      "message": "Invalid email format"
    }
  ]
}
```

### Error response fields

| Field         | Type   | Description                                      |
| ------------- | ------ | ------------------------------------------------ |
| `code`        | string | Machine-readable error code                      |
| `status`      | number | HTTP status code                                 |
| `message`     | string | Brief human-readable message                     |
| `description` | string | Detailed explanation of the error                |
| `details`     | array  | Additional error details (for validation errors) |

## Common error codes

### Authentication errors

| Code                       | Status | Description                                        |
| -------------------------- | ------ | -------------------------------------------------- |
| `missing_authorization`    | 401    | No authentication credentials provided             |
| `invalid_token`            | 401    | The provided token is invalid or expired           |
| `insufficient_permissions` | 403    | Valid credentials but lacking required permissions |
| `missing_scopes`           | 403    | API key doesn't have required scopes               |

### Validation errors

| Code                     | Status | Description                       |
| ------------------------ | ------ | --------------------------------- |
| `validation_error`       | 422    | Request body validation failed    |
| `invalid_parameters`     | 400    | Query parameters are invalid      |
| `missing_required_field` | 422    | A required field is missing       |
| `invalid_field_value`    | 422    | A field contains an invalid value |

### Resource errors

| Code              | Status | Description                                        |
| ----------------- | ------ | -------------------------------------------------- |
| `not_found`       | 404    | The requested resource doesn't exist               |
| `already_exists`  | 409    | A resource with the same identifier already exists |
| `resource_locked` | 423    | The resource is locked and cannot be modified      |

### Rate limiting

| Code           | Status | Description                         |
| -------------- | ------ | ----------------------------------- |
| `rate_limited` | 429    | Too many requests in a short period |

## Error handling examples

<CodeGroup>
  ```javascript JavaScript theme={null}
  try {
    const response = await fetch("https://api.us.firstquadrant.ai/v5/contacts", {
      method: "POST",
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        email: "invalid-email",
        firstName: "John",
      }),
    });

    if (!response.ok) {
      const error = await response.json();

      switch (error.code) {
        case "validation_error":
          console.error("Validation failed:", error.details);
          break;
        case "rate_limited":
          console.error("Rate limit hit, retry after delay");
          break;
        case "missing_authorization":
          console.error("Authentication required");
          break;
        default:
          console.error("API error:", error.message);
      }
    }
  } catch (err) {
    console.error("Network error:", err);
  }
  ```

  ```python Python theme={null}
  import requests
  from time import sleep

  def make_api_request(url, data=None, retry_count=0):
      try:
          response = requests.post(
              url,
              json=data,
              headers={
                  'Authorization': 'Bearer YOUR_API_KEY',
                  'FirstQuadrant-Organization-ID': 'org_YOUR_ORG_ID'
              }
          )

          if response.status_code == 429 and retry_count < 3:
              # Rate limited, retry with exponential backoff
              sleep(2 ** retry_count)
              return make_api_request(url, data, retry_count + 1)

          response.raise_for_status()
          return response.json()

      except requests.exceptions.HTTPError as err:
          error_data = err.response.json()

          if error_data['code'] == 'validation_error':
              print(f"Validation errors: {error_data['details']}")
          else:
              print(f"API error: {error_data['message']}")

          raise
  ```

  ```typescript TypeScript theme={null}
  interface ApiError {
    code: string;
    status: number;
    message: string;
    description: string;
    details?: Array<{
      field: string;
      message: string;
    }>;
  }

  class FirstQuadrantError extends Error {
    constructor(
      public code: string,
      public status: number,
      message: string,
      public details?: any[],
    ) {
      super(message);
    }
  }

  async function apiRequest<T>(endpoint: string, options?: RequestInit): Promise<T> {
    const response = await fetch(`https://api.us.firstquadrant.ai/v5${endpoint}`, {
      ...options,
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
        "Content-Type": "application/json",
        ...options?.headers,
      },
    });

    if (!response.ok) {
      const error: ApiError = await response.json();
      throw new FirstQuadrantError(error.code, error.status, error.message, error.details);
    }

    return response.json();
  }

  // Usage with error handling
  try {
    const contact = await apiRequest("/contacts", {
      method: "POST",
      body: JSON.stringify({ email: "test@example.com" }),
    });
  } catch (error) {
    if (error instanceof FirstQuadrantError) {
      if (error.code === "validation_error") {
        // Handle validation errors
        error.details?.forEach((detail) => {
          console.error(`${detail.field}: ${detail.message}`);
        });
      }
    }
  }
  ```
</CodeGroup>

## Validation error details

When a validation error occurs, the `details` array provides specific information about each field that failed validation:

```json  theme={null}
{
  "code": "validation_error",
  "status": 422,
  "message": "Validation failed",
  "description": "The request body contains invalid data.",
  "details": [
    {
      "field": "email",
      "message": "Invalid email format"
    },
    {
      "field": "phone",
      "message": "Phone number must include country code"
    },
    {
      "field": "customProperties.industry",
      "message": "Industry must be one of: technology, finance, healthcare"
    }
  ]
}
```

## Best practices

1. **Always check the response status** before attempting to parse the response body
2. **Handle rate limiting gracefully** by implementing exponential backoff
3. **Log error details** including the `X-Request-Id` header for debugging
4. **Parse validation errors** to provide user-friendly feedback
5. **Implement retry logic** for transient errors (5xx status codes)
6. **Use the error code** for programmatic error handling rather than parsing messages

## Debugging

When reporting issues, include:

* The `X-Request-Id` header from the response
* The full error response body
* The request method, URL, and headers (excluding sensitive data)
* The request body (if applicable)

This information helps our support team quickly identify and resolve issues.


# Filtering & search
Source: https://docs.firstquadrant.ai/api-reference/filtering

Advanced filtering, search, and field selection for API resources

The FirstQuadrant API provides powerful filtering capabilities to help you find exactly the data you need. This guide covers search queries, advanced filters, and field selection.

## Quick start

```bash  theme={null}
# Search contacts by name or email
curl "https://api.us.firstquadrant.ai/v5/contacts?query=john" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Filter by email domain
curl "https://api.us.firstquadrant.ai/v5/contacts?filter.email.contains=@acme.com" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Select specific fields
curl "https://api.us.firstquadrant.ai/v5/contacts?select[]=id&select[]=email&select[]=firstName" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Search with query parameter

The `query` parameter performs full-text search across relevant fields:

```bash  theme={null}
# Search contacts
GET /v5/contacts?query=john

# Search campaigns
GET /v5/campaigns?query=welcome

# Combine with other filters
GET /v5/contacts?query=john&filter.tags.has=customer
```

The search is case-insensitive and searches across multiple fields depending on the resource type.

## Advanced filtering

### Filter syntax

Filters use the format: `filter.field.operator=value`

```bash  theme={null}
# Single filter
filter.email.equals=john@example.com

# Multiple filters (AND logic)
filter.firstName.equals=John&filter.lastName.contains=Doe

# Nested field filters
filter.customProperties.industry.equals=technology
```

### Available operators

#### String operators

| Operator     | Description                  | Example                                |
| ------------ | ---------------------------- | -------------------------------------- |
| `equals`     | Exact match (case-sensitive) | `filter.email.equals=john@example.com` |
| `not`        | Not equal to                 | `filter.status.not=inactive`           |
| `contains`   | Contains substring           | `filter.email.contains=@gmail.com`     |
| `startsWith` | Starts with string           | `filter.name.startsWith=John`          |
| `endsWith`   | Ends with string             | `filter.email.endsWith=.edu`           |
| `in`         | Value in array               | `filter.status.in=active,pending`      |
| `notIn`      | Value not in array           | `filter.status.notIn=deleted,archived` |

#### Number operators

| Operator | Description           | Example                    |
| -------- | --------------------- | -------------------------- |
| `equals` | Equal to              | `filter.score.equals=100`  |
| `not`    | Not equal to          | `filter.score.not=0`       |
| `gt`     | Greater than          | `filter.score.gt=50`       |
| `gte`    | Greater than or equal | `filter.score.gte=50`      |
| `lt`     | Less than             | `filter.score.lt=100`      |
| `lte`    | Less than or equal    | `filter.score.lte=100`     |
| `in`     | Value in array        | `filter.priority.in=1,2,3` |

#### Date operators

| Operator | Description       | Example                                |
| -------- | ----------------- | -------------------------------------- |
| `equals` | Exact date match  | `filter.createdAt.equals=2024-01-15`   |
| `gt`     | After date        | `filter.createdAt.gt=2024-01-01`       |
| `gte`    | On or after date  | `filter.lastActivityAt.gte=2024-01-01` |
| `lt`     | Before date       | `filter.createdAt.lt=2024-12-31`       |
| `lte`    | On or before date | `filter.updatedAt.lte=2024-12-31`      |

#### Array operators

| Operator   | Description               | Example                             |
| ---------- | ------------------------- | ----------------------------------- |
| `has`      | Array contains value      | `filter.tags.has=customer`          |
| `hasEvery` | Array contains all values | `filter.tags.hasEvery=customer,vip` |
| `hasSome`  | Array contains any value  | `filter.tags.hasSome=lead,prospect` |
| `isEmpty`  | Array is empty            | `filter.tags.isEmpty=true`          |

#### Boolean operators

| Operator | Description      | Example                       |
| -------- | ---------------- | ----------------------------- |
| `equals` | Boolean value    | `filter.isActive.equals=true` |
| `not`    | Opposite boolean | `filter.isVerified.not=true`  |

## Filtering examples

<CodeGroup>
  ```javascript JavaScript theme={null}
  // Advanced filtering with multiple conditions
  const params = new URLSearchParams({
    "filter.status.equals": "active",
    "filter.createdAt.gte": "2024-01-01",
    "filter.tags.hasSome": "customer,lead",
    "filter.customProperties.score.gt": "50",
    query: "john",
  });

  const response = await fetch(`https://api.us.firstquadrant.ai/v5/contacts?${params}`, {
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
      "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
    },
  });

  const contacts = await response.json();
  ```

  ```python Python theme={null}
  import requests
  from datetime import datetime, timedelta

  # Filter contacts created in the last 30 days with high scores
  thirty_days_ago = (datetime.now() - timedelta(days=30)).isoformat()

  params = {
      'filter.createdAt.gte': thirty_days_ago,
      'filter.customProperties.leadScore.gt': 80,
      'filter.email.endsWith': '.com',
      'orderBy': 'customProperties.leadScore',
      'sort': 'desc',
      'limit': 50
  }

  response = requests.get(
      'https://api.us.firstquadrant.ai/v5/contacts',
      params=params,
      headers={
          'Authorization': 'Bearer YOUR_API_KEY',
          'FirstQuadrant-Organization-ID': 'org_YOUR_ORG_ID'
      }
  )

  high_value_leads = response.json()
  ```

  ```typescript TypeScript theme={null}
  interface ContactFilter {
    email?: {
      equals?: string;
      contains?: string;
      startsWith?: string;
      endsWith?: string;
    };
    tags?: {
      has?: string;
      hasEvery?: string;
      hasSome?: string;
      isEmpty?: boolean;
    };
    createdAt?: {
      gt?: string;
      gte?: string;
      lt?: string;
      lte?: string;
    };
    customProperties?: {
      [key: string]: {
        equals?: any;
        gt?: number;
        contains?: string;
      };
    };
  }

  function buildFilterParams(filters: ContactFilter): URLSearchParams {
    const params = new URLSearchParams();

    Object.entries(filters).forEach(([field, operators]) => {
      Object.entries(operators).forEach(([operator, value]) => {
        if (field === "customProperties") {
          // Handle nested properties
          Object.entries(value).forEach(([prop, propOperators]) => {
            Object.entries(propOperators).forEach(([op, val]) => {
              params.append(`filter.${field}.${prop}.${op}`, String(val));
            });
          });
        } else {
          params.append(`filter.${field}.${operator}`, String(value));
        }
      });
    });

    return params;
  }

  // Usage
  const filters: ContactFilter = {
    email: { endsWith: "@company.com" },
    tags: { hasSome: "customer,lead" },
    createdAt: { gte: "2024-01-01" },
    customProperties: {
      industry: { equals: "technology" },
      employeeCount: { gt: 100 },
    },
  };

  const params = buildFilterParams(filters);
  const response = await fetch(`https://api.us.firstquadrant.ai/v5/contacts?${params}`);
  ```
</CodeGroup>

## Field selection

Use the `select[]` parameter to specify which fields to include in the response:

### Basic field selection

```bash  theme={null}
# Select only id, email, and name fields
GET /v5/contacts?select[]=id&select[]=email&select[]=firstName&select[]=lastName

# Response includes only selected fields
[
  {
    "id": "con_abc123",
    "email": "john@example.com",
    "firstName": "John",
    "lastName": "Doe"
  }
]
```

### Nested field selection

Use dot notation for nested fields:

```bash  theme={null}
# Select nested fields
GET /v5/contacts?select[]=id&select[]=email&select[]=company.name&select[]=customProperties.score

# Response
[
  {
    "id": "con_abc123",
    "email": "john@example.com",
    "company": {
      "name": "Acme Corp"
    },
    "customProperties": {
      "score": 85
    }
  }
]
```

### Performance benefits

Field selection reduces payload size and improves performance:

```javascript  theme={null}
// Fetch only essential fields for a list view
const listParams = new URLSearchParams({
  "select[]": ["id", "email", "firstName", "lastName", "company.name"],
  limit: "100",
});

// Fetch all fields for a detail view
const detailResponse = await fetch(`https://api.us.firstquadrant.ai/v5/contacts/${contactId}`);
```

## Complex filter combinations

### Example 1: Sales qualified leads

Find high-value leads from specific industries:

```bash  theme={null}
GET /v5/contacts?
  filter.customProperties.leadScore.gte=80&
  filter.customProperties.industry.in=technology,finance,healthcare&
  filter.tags.has=qualified&
  filter.lastActivityAt.gte=2024-01-01&
  orderBy=customProperties.leadScore&
  sort=desc
```

### Example 2: Email campaign targets

Find contacts for an email campaign:

```bash  theme={null}
GET /v5/contacts?
  filter.email.endsWith=.com&
  filter.emailOptOut.equals=false&
  filter.tags.hasEvery=customer,active&
  filter.customProperties.lastPurchaseDate.gte=2023-01-01&
  select[]=id&
  select[]=email&
  select[]=firstName
```

### Example 3: Data cleanup

Find potentially duplicate contacts:

```bash  theme={null}
GET /v5/contacts?
  filter.email.contains=@gmail.com&
  filter.createdAt.gte=2024-01-01&
  orderBy=email&
  sort=asc
```

## Special filters

### Null and empty values

```bash  theme={null}
# Find contacts without a company
filter.companyId.equals=null

# Find contacts with no tags
filter.tags.isEmpty=true

# Find contacts with any tags
filter.tags.isEmpty=false
```

### Date ranges

```javascript  theme={null}
// Contacts created this month
const startOfMonth = new Date();
startOfMonth.setDate(1);
startOfMonth.setHours(0, 0, 0, 0);

const params = new URLSearchParams({
  "filter.createdAt.gte": startOfMonth.toISOString(),
  "filter.createdAt.lt": new Date().toISOString(),
});
```

### Pattern matching

```bash  theme={null}
# Email domains
filter.email.endsWith=@company.com

# Phone numbers with area code
filter.phone.startsWith=+1415

# Names containing substring
filter.firstName.contains=john
```

## Filter limits and performance

### Best practices

1. **Use indexes**: Filter on indexed fields (id, email, createdAt) for better performance
2. **Limit results**: Always use pagination with filters
3. **Select fields**: Only request fields you need
4. **Combine wisely**: Too many filters can slow queries

### Performance tips

```javascript  theme={null}
// ❌ Inefficient: Fetching all fields for large dataset
const response = await fetch("/v5/contacts?limit=100");

// ✅ Efficient: Select only needed fields with filters
const response = await fetch(
  "/v5/contacts?" + "filter.status.equals=active&" + "select[]=id&select[]=email&select[]=name&" + "limit=50",
);
```

## Common use cases

### 1. Segmentation

```javascript  theme={null}
// VIP customers in California
const vipCA = {
  "filter.tags.has": "vip",
  "filter.customProperties.state.equals": "CA",
  "filter.customProperties.lifetimeValue.gt": "10000",
};
```

### 2. Time-based queries

```javascript  theme={null}
// Contacts inactive for 90 days
const ninetyDaysAgo = new Date();
ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);

const inactive = {
  "filter.lastActivityAt.lt": ninetyDaysAgo.toISOString(),
  "filter.status.equals": "active",
};
```

### 3. Data export

```javascript  theme={null}
// Export specific fields with filters
async function exportContacts(filters) {
  const params = new URLSearchParams({
    ...filters,
    "select[]": ["id", "email", "firstName", "lastName", "createdAt"],
    limit: "100",
  });

  // Paginate through all results
  let allContacts = [];
  let hasMore = true;
  let cursor = null;

  while (hasMore) {
    if (cursor) params.set("startingAfter", cursor);

    const response = await fetch(`/v5/contacts?${params}`);
    const page = await response.json();

    allContacts = allContacts.concat(page);
    hasMore = page.length === 100;

    if (hasMore) cursor = page[page.length - 1].id;
  }

  return allContacts;
}
```

## Troubleshooting

### Common issues

1. **Invalid operator**: Ensure the operator is valid for the field type
2. **Field not found**: Check field names and nested paths
3. **Type mismatch**: Ensure filter values match the field type
4. **Special characters**: URL-encode special characters in filter values

### Debugging tips

```javascript  theme={null}
// Log the exact URL being called
const params = new URLSearchParams(filters);
console.log(`API URL: https://api.us.firstquadrant.ai/v5/contacts?${params}`);

// Check response headers for debugging info
const response = await fetch(url);
console.log("Request ID:", response.headers.get("X-Request-Id"));
```


# Getting started
Source: https://docs.firstquadrant.ai/api-reference/getting-started

Quick start guide for integrating with the FirstQuadrant API

The FirstQuadrant API provides programmatic access to all the features of the FirstQuadrant CRM platform. This guide will help you get started with making your first API call.

## Base URL

All API requests should be made to:

```
https://api.us.firstquadrant.ai/v5
```

## Authentication

Before making any API requests, you'll need to authenticate. FirstQuadrant supports two authentication methods:

1. **API Keys** - Best for server-to-server integrations
2. **Access Tokens** - For user-specific actions

See the [Authentication](/api-reference/authentication) guide for detailed instructions on obtaining and using credentials.

## Making your first request

Here's a simple example to test your authentication and get your user profile:

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.us.firstquadrant.ai/v5/me \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "FirstQuadrant-Organization-ID: org_YOUR_ORG_ID"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch("https://api.us.firstquadrant.ai/v5/me", {
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
      "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
    },
  });

  const user = await response.json();
  console.log(user);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.us.firstquadrant.ai/v5/me',
      headers={
          'Authorization': 'Bearer YOUR_API_KEY',
          'FirstQuadrant-Organization-ID': 'org_YOUR_ORG_ID'
      }
  )

  user = response.json()
  print(user)
  ```

  ```typescript TypeScript theme={null}
  interface User {
    id: string;
    email: string;
    name: string;
    organizations: Array<{
      id: string;
      name: string;
      role: string;
    }>;
  }

  const response = await fetch("https://api.us.firstquadrant.ai/v5/me", {
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
      "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
    },
  });

  const user: User = await response.json();
  ```
</CodeGroup>

## Response format

All successful API responses return JSON data. The response will vary based on the endpoint, but typically follows these patterns:

### Single resource

```json  theme={null}
{
  "id": "con_abc123",
  "email": "john@example.com",
  "firstName": "John",
  "lastName": "Doe",
  "createdAt": "2024-01-15T10:30:00Z",
  "updatedAt": "2024-01-15T10:30:00Z"
}
```

### Resource collection

```json  theme={null}
[
  {
    "id": "con_abc123",
    "email": "john@example.com",
    "firstName": "John",
    "lastName": "Doe"
  },
  {
    "id": "con_def456",
    "email": "jane@example.com",
    "firstName": "Jane",
    "lastName": "Smith"
  }
]
```

## Common headers

### Request headers

| Header                          | Required | Description                                    |
| ------------------------------- | -------- | ---------------------------------------------- |
| `Authorization`                 | Yes      | Bearer token or API key                        |
| `FirstQuadrant-Organization-ID` | Yes\*    | Organization context (required for API keys)   |
| `Content-Type`                  | Yes\*\*  | `application/json` for POST/PUT/PATCH requests |

\*Required when using API keys, optional for access tokens
\*\*Required when sending request body

### Response headers

| Header         | Description                       |
| -------------- | --------------------------------- |
| `X-Request-Id` | Unique identifier for the request |
| `Version`      | API version information           |
| `ETag`         | Entity tag for caching            |

## Next steps

Now that you've made your first API call, explore these topics:

* [Error Handling](/api-reference/errors) - Learn how to handle API errors
* [Pagination](/api-reference/pagination) - Work with large datasets
* [Filtering](/api-reference/filtering) - Query and filter resources
* [Best Practices](/api-reference/best-practices) - Tips for efficient API usage

## API explorer

You can explore all available endpoints and test them interactively using our API documentation:

* **OpenAPI Specification**: [https://api.us.firstquadrant.ai/v5/docs](https://api.us.firstquadrant.ai/v5/docs)
* **Swagger UI**: [https://api.us.firstquadrant.ai/v5/swagger](https://api.us.firstquadrant.ai/v5/swagger)

## Support

If you have questions or need help with the API:

* Check our [API Reference](/api-reference) for detailed endpoint documentation
* Review [Best Practices](/api-reference/best-practices) for common patterns
* Contact support at [support@firstquadrant.ai](mailto:support@firstquadrant.ai)


# Pagination
Source: https://docs.firstquadrant.ai/api-reference/pagination

Learn how to navigate through large datasets using cursor-based pagination

The FirstQuadrant API uses cursor-based pagination to efficiently navigate through large collections of resources. This approach provides consistent results even when data is being modified.

## Pagination parameters

All collection endpoints support the following query parameters:

| Parameter       | Type    | Default     | Description                       |
| --------------- | ------- | ----------- | --------------------------------- |
| `limit`         | integer | 25          | Number of items to return (1-100) |
| `startingAfter` | string  | -           | Cursor for forward pagination     |
| `endingBefore`  | string  | -           | Cursor for backward pagination    |
| `orderBy`       | string  | `createdAt` | Field to sort by                  |
| `sort`          | string  | `desc`      | Sort direction (`asc` or `desc`)  |

## How it works

1. **Initial Request**: Make a request without pagination parameters to get the first page
2. **Get Next Page**: Use the `id` of the last item as `startingAfter`
3. **Get Previous Page**: Use the `id` of the first item as `endingBefore`
4. **Check for More**: If the returned items equal the limit, more pages may exist

## Basic pagination example

<CodeGroup>
  ```bash cURL theme={null}
  # Get first page of contacts
  curl "https://api.us.firstquadrant.ai/v5/contacts?limit=10" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "FirstQuadrant-Organization-ID: org_YOUR_ORG_ID"

  # Get next page using the last contact's ID
  curl "https://api.us.firstquadrant.ai/v5/contacts?limit=10&startingAfter=con_abc123" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "FirstQuadrant-Organization-ID: org_YOUR_ORG_ID"
  ```

  ```javascript JavaScript theme={null}
  async function getAllContacts() {
    const contacts = [];
    let hasMore = true;
    let lastId = null;

    while (hasMore) {
      const params = new URLSearchParams({
        limit: "50",
        ...(lastId && { startingAfter: lastId }),
      });

      const response = await fetch(`https://api.us.firstquadrant.ai/v5/contacts?${params}`, {
        headers: {
          Authorization: "Bearer YOUR_API_KEY",
          "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
        },
      });

      const page = await response.json();
      contacts.push(...page);

      // Check if there are more pages
      hasMore = page.length === 50;
      if (hasMore) {
        lastId = page[page.length - 1].id;
      }
    }

    return contacts;
  }
  ```

  ```python Python theme={null}
  def get_all_contacts(api_key, org_id):
      contacts = []
      has_more = True
      starting_after = None

      while has_more:
          params = {
              'limit': 50
          }
          if starting_after:
              params['startingAfter'] = starting_after

          response = requests.get(
              'https://api.us.firstquadrant.ai/v5/contacts',
              params=params,
              headers={
                  'Authorization': f'Bearer {api_key}',
                  'FirstQuadrant-Organization-ID': org_id
              }
          )

          page = response.json()
          contacts.extend(page)

          # Check if there are more pages
          has_more = len(page) == 50
          if has_more:
              starting_after = page[-1]['id']

      return contacts
  ```

  ```typescript TypeScript theme={null}
  interface PaginationParams {
    limit?: number;
    startingAfter?: string;
    endingBefore?: string;
    orderBy?: string;
    sort?: "asc" | "desc";
  }

  async function* paginateContacts(params: PaginationParams = {}): AsyncGenerator<Contact[]> {
    let hasMore = true;
    let cursor: string | undefined;

    while (hasMore) {
      const searchParams = new URLSearchParams({
        limit: String(params.limit || 50),
        ...(cursor && { startingAfter: cursor }),
        ...(params.orderBy && { orderBy: params.orderBy }),
        ...(params.sort && { sort: params.sort }),
      });

      const response = await fetch(`https://api.us.firstquadrant.ai/v5/contacts?${searchParams}`, {
        headers: {
          Authorization: "Bearer YOUR_API_KEY",
          "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
        },
      });

      const page: Contact[] = await response.json();
      yield page;

      hasMore = page.length === (params.limit || 50);
      if (hasMore && page.length > 0) {
        cursor = page[page.length - 1].id;
      }
    }
  }

  // Usage
  for await (const page of paginateContacts({ limit: 25 })) {
    console.log(`Processing ${page.length} contacts`);
    // Process each page
  }
  ```
</CodeGroup>

## Sorting results

You can sort results by any field that's included in the response:

```bash  theme={null}
# Sort by email address in ascending order
curl "https://api.us.firstquadrant.ai/v5/contacts?orderBy=email&sort=asc" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Sort by last activity date (most recent first)
curl "https://api.us.firstquadrant.ai/v5/contacts?orderBy=lastActivityAt&sort=desc" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Sort by custom property
curl "https://api.us.firstquadrant.ai/v5/contacts?orderBy=customProperties.score&sort=desc" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Getting total count

To get the total number of items without fetching all data, use the count endpoint:

```bash  theme={null}
# Get total number of contacts
curl "https://api.us.firstquadrant.ai/v5/contacts/count" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "FirstQuadrant-Organization-ID: org_YOUR_ORG_ID"

# Response
{
  "count": 1234
}
```

You can also apply filters to the count endpoint:

```bash  theme={null}
# Count contacts with a specific tag
curl "https://api.us.firstquadrant.ai/v5/contacts/count?tags=customer" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "FirstQuadrant-Organization-ID: org_YOUR_ORG_ID"
```

## Combining with filters

Pagination works seamlessly with filtering and search:

```bash  theme={null}
# Paginate through filtered results
curl "https://api.us.firstquadrant.ai/v5/contacts?query=john&limit=20&startingAfter=con_abc123" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Paginate with advanced filters
curl "https://api.us.firstquadrant.ai/v5/contacts?filter.email.contains=@company.com&limit=50" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Best practices

### 1. Choose appropriate page sizes

* Use smaller limits (10-25) for real-time UI updates
* Use larger limits (50-100) for batch processing
* Maximum limit is 100 items per request

### 2. Handle edge cases

```javascript  theme={null}
// Handle empty results
if (page.length === 0) {
  console.log('No more results');
  break;
}

// Handle deleted items
try {
  const page = await fetchPage(cursor);
} catch (error) {
  if (error.code === 'not_found') {
    // Item used as cursor was deleted, start over
    cursor = null;
    continue;
  }
}
```

### 3. Implement progress tracking

```javascript  theme={null}
async function exportContactsWithProgress() {
  // First, get the total count
  const { count } = await fetchCount();
  let processed = 0;

  for await (const page of paginateContacts()) {
    processed += page.length;
    console.log(`Progress: ${processed}/${count} (${Math.round((processed / count) * 100)}%)`);

    // Process page...
  }
}
```

### 4. Optimize for performance

* Use field selection to reduce payload size
* Process pages in parallel when order doesn't matter
* Cache results when appropriate

```javascript  theme={null}
// Fetch only required fields
const params = new URLSearchParams({
  limit: "100",
  "select[]": ["id", "email", "firstName", "lastName"],
});

// Process multiple pages in parallel
const pagePromises = [];
for (let i = 0; i < 5; i++) {
  pagePromises.push(fetchPage(cursors[i]));
}
const pages = await Promise.all(pagePromises);
```

## Common patterns

### Bidirectional navigation

```javascript  theme={null}
class PaginationState {
  constructor() {
    this.currentPage = [];
    this.prevCursor = null;
    this.nextCursor = null;
  }

  async loadNext() {
    const params = {
      limit: 25,
      ...(this.nextCursor && { startingAfter: this.nextCursor }),
    };

    const page = await fetchContacts(params);

    if (page.length > 0) {
      this.prevCursor = page[0].id;
      this.nextCursor = page[page.length - 1].id;
      this.currentPage = page;
    }

    return page;
  }

  async loadPrev() {
    const params = {
      limit: 25,
      endingBefore: this.prevCursor,
    };

    const page = await fetchContacts(params);

    if (page.length > 0) {
      this.prevCursor = page[0].id;
      this.nextCursor = page[page.length - 1].id;
      this.currentPage = page;
    }

    return page;
  }
}
```

### Infinite scroll implementation

```javascript  theme={null}
class InfiniteScroll {
  constructor(container, fetchFn) {
    this.container = container;
    this.fetchFn = fetchFn;
    this.cursor = null;
    this.loading = false;
    this.hasMore = true;

    this.observeLastItem();
  }

  async loadMore() {
    if (this.loading || !this.hasMore) return;

    this.loading = true;

    const items = await this.fetchFn(this.cursor);

    if (items.length > 0) {
      this.cursor = items[items.length - 1].id;
      this.renderItems(items);
      this.hasMore = items.length === 50;
    } else {
      this.hasMore = false;
    }

    this.loading = false;
  }

  observeLastItem() {
    const observer = new IntersectionObserver((entries) => {
      if (entries[0].isIntersecting) {
        this.loadMore();
      }
    });

    // Observe the last item in the container
    const lastItem = this.container.lastElementChild;
    if (lastItem) observer.observe(lastItem);
  }
}
```

## Troubleshooting

### No results returned

If you're not getting expected results:

1. Check if filters are too restrictive
2. Verify the cursor ID exists and belongs to the same resource type
3. Ensure you're not mixing `startingAfter` and `endingBefore`

### Performance issues

For better performance:

1. Use larger page sizes (up to 100)
2. Limit the fields returned with `select[]`
3. Use count endpoint separately instead of fetching all data
4. Consider caching results for static data


# Rate limiting
Source: https://docs.firstquadrant.ai/api-reference/rate-limiting

Understanding and working with API rate limits

The FirstQuadrant API implements rate limiting to ensure fair usage and maintain service reliability for all users. This guide explains our rate limits and how to handle them gracefully.

## Current rate limits

### Authentication endpoints

Authentication endpoints have stricter rate limits for security:

| Endpoint           | Limit       | Window   |
| ------------------ | ----------- | -------- |
| `/v5/auth`         | 30 requests | 1 minute |
| `/v5/auth/refresh` | 30 requests | 1 minute |
| `/v5/auth/login`   | 30 requests | 1 minute |

### Standard API endpoints

Currently, standard API endpoints do not have publicly-available rate limits. We recommend implementing rate limit handling in your code to ensure compatibility with future updates.

## Rate limit response

When you exceed the rate limit, you'll receive a `429 Too Many Requests` response:

```json  theme={null}
{
  "code": "rate_limited",
  "status": 429,
  "message": "Too many requests",
  "description": "You have exceeded the rate limit. Please wait before making more requests."
}
```

## Handling rate limits

### Exponential backoff

The recommended approach is to implement exponential backoff with jitter:

<CodeGroup>
  ```javascript JavaScript theme={null}
  async function makeRequestWithRetry(url, options, maxRetries = 3) {
    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        const response = await fetch(url, options);

        if (response.status === 429) {
          if (attempt === maxRetries) {
            throw new Error("Rate limit exceeded after maximum retries");
          }

          // Exponential backoff with jitter
          const baseDelay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
          const jitter = Math.random() * 1000; // 0-1s random jitter
          const delay = baseDelay + jitter;

          console.log(`Rate limited. Retrying in ${delay}ms...`);
          await new Promise((resolve) => setTimeout(resolve, delay));
          continue;
        }

        return response;
      } catch (error) {
        if (attempt === maxRetries) throw error;
      }
    }
  }

  // Usage
  const response = await makeRequestWithRetry("https://api.us.firstquadrant.ai/v5/contacts", {
    headers: {
      Authorization: "Bearer YOUR_API_KEY",
      "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
    },
  });
  ```

  ```python Python theme={null}
  import time
  import random
  import requests
  from typing import Optional, Dict, Any

  def make_request_with_retry(
      url: str,
      headers: Dict[str, str],
      method: str = 'GET',
      data: Optional[Any] = None,
      max_retries: int = 3
  ) -> requests.Response:
      """Make an API request with exponential backoff retry logic."""

      for attempt in range(max_retries + 1):
          try:
              response = requests.request(
                  method=method,
                  url=url,
                  headers=headers,
                  json=data
              )

              if response.status_code == 429:
                  if attempt == max_retries:
                      response.raise_for_status()

                  # Exponential backoff with jitter
                  base_delay = (2 ** attempt)  # 1s, 2s, 4s
                  jitter = random.random()  # 0-1s random
                  delay = base_delay + jitter

                  print(f"Rate limited. Retrying in {delay:.2f} seconds...")
                  time.sleep(delay)
                  continue

              response.raise_for_status()
              return response

          except requests.exceptions.RequestException as e:
              if attempt == max_retries:
                  raise

              # Network errors also trigger retry
              delay = (2 ** attempt) + random.random()
              print(f"Request failed: {e}. Retrying in {delay:.2f} seconds...")
              time.sleep(delay)

  # Usage
  response = make_request_with_retry(
      url='https://api.us.firstquadrant.ai/v5/contacts',
      headers={
          'Authorization': 'Bearer YOUR_API_KEY',
          'FirstQuadrant-Organization-ID': 'org_YOUR_ORG_ID'
      }
  )
  ```

  ```typescript TypeScript theme={null}
  interface RetryOptions {
    maxRetries?: number;
    initialDelay?: number;
    maxDelay?: number;
  }

  class RateLimitError extends Error {
    constructor(public retryAfter?: number) {
      super("Rate limit exceeded");
      this.name = "RateLimitError";
    }
  }

  async function fetchWithRetry(url: string, options: RequestInit, retryOptions: RetryOptions = {}): Promise<Response> {
    const { maxRetries = 3, initialDelay = 1000, maxDelay = 32000 } = retryOptions;

    let lastError: Error | null = null;

    for (let attempt = 0; attempt <= maxRetries; attempt++) {
      try {
        const response = await fetch(url, options);

        if (response.status === 429) {
          if (attempt === maxRetries) {
            throw new RateLimitError();
          }

          // Calculate delay with exponential backoff and jitter
          const baseDelay = Math.min(initialDelay * Math.pow(2, attempt), maxDelay);
          const jitter = Math.random() * 1000;
          const delay = baseDelay + jitter;

          console.log(`Rate limited. Retry ${attempt + 1}/${maxRetries} in ${Math.round(delay)}ms`);
          await new Promise((resolve) => setTimeout(resolve, delay));
          continue;
        }

        return response;
      } catch (error) {
        lastError = error as Error;

        if (attempt < maxRetries) {
          const delay = initialDelay * Math.pow(2, attempt);
          await new Promise((resolve) => setTimeout(resolve, delay));
        }
      }
    }

    throw lastError || new Error("Request failed after retries");
  }

  // Usage with a rate limit handler
  async function apiRequest<T>(endpoint: string, options?: RequestInit): Promise<T> {
    const response = await fetchWithRetry(`https://api.us.firstquadrant.ai/v5${endpoint}`, {
      ...options,
      headers: {
        Authorization: "Bearer YOUR_API_KEY",
        "FirstQuadrant-Organization-ID": "org_YOUR_ORG_ID",
        "Content-Type": "application/json",
        ...options?.headers,
      },
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message);
    }

    return response.json();
  }
  ```
</CodeGroup>

## Best practices

### 1. Implement retry logic

Always implement retry logic with exponential backoff:

```javascript  theme={null}
// Good: Exponential backoff with jitter
const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000;

// Bad: Fixed delay
const delay = 1000;

// Bad: No retry logic
if (response.status === 429) throw new Error("Rate limited");
```

### 2. Queue requests

For high-volume applications, implement a request queue:

```javascript  theme={null}
class RequestQueue {
  constructor(maxConcurrent = 5, minDelay = 100) {
    this.queue = [];
    this.active = 0;
    this.maxConcurrent = maxConcurrent;
    this.minDelay = minDelay;
    this.lastRequestTime = 0;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.active >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }

    // Ensure minimum delay between requests
    const now = Date.now();
    const timeSinceLastRequest = now - this.lastRequestTime;

    if (timeSinceLastRequest < this.minDelay) {
      setTimeout(() => this.process(), this.minDelay - timeSinceLastRequest);
      return;
    }

    const { requestFn, resolve, reject } = this.queue.shift();
    this.active++;
    this.lastRequestTime = Date.now();

    try {
      const result = await requestFn();
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.active--;
      this.process();
    }
  }
}

// Usage
const queue = new RequestQueue(5, 200); // Max 5 concurrent, 200ms between requests

async function fetchAllContacts() {
  const pagePromises = [];

  for (let page = 1; page <= 10; page++) {
    pagePromises.push(queue.add(() => fetch(`/v5/contacts?page=${page}`, { headers })));
  }

  return Promise.all(pagePromises);
}
```

### 3. Monitor rate limit usage

Track your API usage to avoid hitting limits:

```javascript  theme={null}
class RateLimitMonitor {
  constructor(limit, window) {
    this.limit = limit;
    this.window = window;
    this.requests = [];
  }

  canMakeRequest() {
    const now = Date.now();
    const windowStart = now - this.window;

    // Remove old requests outside the window
    this.requests = this.requests.filter((time) => time > windowStart);

    return this.requests.length < this.limit;
  }

  recordRequest() {
    this.requests.push(Date.now());
  }

  async waitForSlot() {
    if (this.canMakeRequest()) return;

    const oldestRequest = this.requests[0];
    const waitTime = this.window - (Date.now() - oldestRequest) + 100;

    console.log(`Rate limit approaching. Waiting ${waitTime}ms...`);
    await new Promise((resolve) => setTimeout(resolve, waitTime));
  }
}

// Usage for auth endpoints (30 req/min)
const authLimiter = new RateLimitMonitor(30, 60000);

async function authenticate() {
  await authLimiter.waitForSlot();

  const response = await fetch("/v5/auth", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ token: refreshToken }),
  });

  authLimiter.recordRequest();

  return response;
}
```

### 4. Batch operations

Reduce API calls by batching operations where possible:

```javascript  theme={null}
// Instead of individual requests
for (const contact of contacts) {
  await updateContact(contact.id, contact.data); // ❌ Many requests
}

// Batch updates in groups
const batchSize = 50;
for (let i = 0; i < contacts.length; i += batchSize) {
  const batch = contacts.slice(i, i + batchSize);
  // Process batch together
  await processBatch(batch); // ✅ Fewer requests
}
```

### 5. Cache responses

Implement caching to reduce redundant API calls:

```javascript  theme={null}
class APICache {
  constructor(ttl = 300000) {
    // 5 minutes default
    this.cache = new Map();
    this.ttl = ttl;
  }

  get(key) {
    const item = this.cache.get(key);
    if (!item) return null;

    if (Date.now() > item.expiry) {
      this.cache.delete(key);
      return null;
    }

    return item.value;
  }

  set(key, value) {
    this.cache.set(key, {
      value,
      expiry: Date.now() + this.ttl,
    });
  }

  async fetch(key, fetchFn) {
    const cached = this.get(key);
    if (cached) return cached;

    const value = await fetchFn();
    this.set(key, value);
    return value;
  }
}

// Usage
const cache = new APICache();

async function getContact(id) {
  return cache.fetch(`contact:${id}`, async () => {
    const response = await fetch(`/v5/contacts/${id}`, { headers });
    return response.json();
  });
}
```

## Error recovery strategies

### Circuit breaker pattern

Implement a circuit breaker to prevent cascading failures:

```javascript  theme={null}
class CircuitBreaker {
  constructor(threshold = 5, timeout = 60000) {
    this.failureCount = 0;
    this.threshold = threshold;
    this.timeout = timeout;
    this.state = "CLOSED"; // CLOSED, OPEN, HALF_OPEN
    this.nextAttempt = Date.now();
  }

  async execute(requestFn) {
    if (this.state === "OPEN") {
      if (Date.now() < this.nextAttempt) {
        throw new Error("Circuit breaker is OPEN");
      }
      this.state = "HALF_OPEN";
    }

    try {
      const result = await requestFn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  onSuccess() {
    this.failureCount = 0;
    this.state = "CLOSED";
  }

  onFailure() {
    this.failureCount++;

    if (this.failureCount >= this.threshold) {
      this.state = "OPEN";
      this.nextAttempt = Date.now() + this.timeout;
      console.log(`Circuit breaker opened. Retry after ${new Date(this.nextAttempt)}`);
    }
  }
}

// Usage
const breaker = new CircuitBreaker();

async function makeAPICall() {
  return breaker.execute(async () => {
    const response = await fetch("/v5/contacts", { headers });

    if (response.status === 429) {
      throw new Error("Rate limited");
    }

    return response.json();
  });
}
```

## Testing rate limits

When developing, test your rate limit handling:

```javascript  theme={null}
// Simulate rate limit scenarios
async function testRateLimitHandling() {
  const requests = [];

  // Make rapid requests to trigger rate limit
  for (let i = 0; i < 40; i++) {
    requests.push(
      makeRequestWithRetry("/v5/auth", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ test: true }),
      }),
    );
  }

  try {
    const results = await Promise.allSettled(requests);

    const successful = results.filter((r) => r.status === "fulfilled").length;
    const failed = results.filter((r) => r.status === "rejected").length;

    console.log(`Successful: ${successful}, Failed: ${failed}`);
  } catch (error) {
    console.error("Test failed:", error);
  }
}
```

## Future considerations

While most endpoints currently don't have publicly-available rate limits, this may change. Design your integration to:

1. **Handle 429 responses** gracefully even on endpoints without current limits
2. **Monitor response headers** for future rate limit information
3. **Implement configurable delays** between requests
4. **Use pagination** to reduce the number of requests
5. **Cache data** where appropriate

By following these practices, your integration will continue to work smoothly as the API evolves.


# API versioning
Source: https://docs.firstquadrant.ai/api-reference/versioning

Understanding API versions, breaking changes, and migration strategies

The FirstQuadrant API uses URL-based versioning to ensure backward compatibility while allowing for continuous improvement. This guide explains our versioning strategy and how to handle version changes.

## Current version

The current API version is **v5**, accessible at:

```
https://api.us.firstquadrant.ai/v5
```

## Version format

### URL versioning

API versions are included in the URL path:

```bash  theme={null}
# Current version
https://api.us.firstquadrant.ai/v5/contacts

# Previous versions (deprecated)
https://api.us.firstquadrant.ai/v4/contacts
https://api.us.firstquadrant.ai/v3/contacts
```

### Version header

Every API response includes a `Version` header with detailed version information:

```
Version: firstquadrant.ai-2024-01-15-a1b2c3d4
```

Format: `firstquadrant.ai-YYYY-MM-DD-{commitHash}`

This header provides:

* **Date**: When this version was deployed
* **Commit Hash**: The exact code version running

## Version lifecycle

### Version support policy

| Version | Status      | Support End Date | Notes                            |
| ------- | ----------- | ---------------- | -------------------------------- |
| v5      | **Current** | -                | Latest features and improvements |
| v4      | Deprecated  | 2024-12-31       | Security fixes only              |
| v3      | End of Life | 2023-12-31       | No longer available              |

### Deprecation timeline

1. **Announcement**: 6 months before deprecation
2. **Deprecation**: Version marked as deprecated, security fixes only
3. **End of Life**: 12 months after deprecation announcement
4. **Removal**: API version no longer accessible

## Breaking vs non-breaking changes

### Non-breaking changes (no version change)

These changes are made without incrementing the API version:

* Adding new endpoints
* Adding new optional fields to responses
* Adding new optional parameters to requests
* Adding new values to enums (when the client can handle unknown values)
* Performance improvements
* Bug fixes

### Breaking changes (new version required)

These changes require a new API version:

* Removing endpoints
* Removing or renaming fields
* Changing field types
* Changing authentication methods
* Modifying validation rules
* Changing error response formats
* Removing enum values

## Checking your API version

### Via cURL

```bash  theme={null}
curl -I https://api.us.firstquadrant.ai/v5/me \
  -H "Authorization: Bearer YOUR_API_KEY"

# Response headers include:
# Version: firstquadrant.ai-2024-01-15-a1b2c3d4
```

### Programmatically

```javascript  theme={null}
const response = await fetch("https://api.us.firstquadrant.ai/v5/me", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const version = response.headers.get("Version");
console.log("API Version:", version);
```

## Migration guide

### Preparing for version changes

1. **Monitor Deprecation Notices**: Subscribe to API changelog
2. **Test Early**: Use staging environment to test new versions
3. **Gradual Migration**: Update services incrementally
4. **Version Abstraction**: Implement version handling in your client

### Version abstraction pattern

```javascript  theme={null}
class FirstQuadrantClient {
  constructor(config) {
    this.apiKey = config.apiKey;
    this.version = config.version || "v5";
    this.baseUrl = `https://api.us.firstquadrant.ai/${this.version}`;
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;

    const response = await fetch(url, {
      ...options,
      headers: {
        Authorization: `Bearer ${this.apiKey}`,
        "Content-Type": "application/json",
        ...options.headers,
      },
    });

    // Log version for monitoring
    console.log("API Version:", response.headers.get("Version"));

    return response;
  }

  // Version-specific handling
  async getContacts(params) {
    switch (this.version) {
      case "v5":
        return this.getContactsV5(params);
      case "v4":
        return this.getContactsV4(params);
      default:
        throw new Error(`Unsupported API version: ${this.version}`);
    }
  }

  async getContactsV5(params) {
    // v5 implementation with new features
    const queryParams = new URLSearchParams({
      ...params,
      // v5 supports advanced filtering
      "filter.status.equals": params.status,
    });

    return this.request(`/contacts?${queryParams}`);
  }

  async getContactsV4(params) {
    // v4 implementation with compatibility layer
    const queryParams = new URLSearchParams({
      ...params,
      // v4 uses different parameter format
      status: params.status,
    });

    return this.request(`/contacts?${queryParams}`);
  }
}
```

## Version-specific changes

### v5 (Current)

Released: January 2024

**New Features:**

* Advanced filtering with dot notation
* Cursor-based pagination improvements
* Enhanced field selection
* Batch operation support
* Improved error responses

**Breaking Changes from v4:**

* Filter syntax changed from `filter[field][op]` to `filter.field.op`
* Removed deprecated `/legacy` endpoints
* Standardized ID prefixes across all resources

### v4 to v5 migration

#### Filter syntax update

```javascript  theme={null}
// v4 syntax
const v4Params = {
  "filter[email][contains]": "@example.com",
  "filter[tags][has]": "customer",
};

// v5 syntax
const v5Params = {
  "filter.email.contains": "@example.com",
  "filter.tags.has": "customer",
};

// Migration helper
function migrateFilters(v4Filters) {
  const v5Filters = {};

  for (const [key, value] of Object.entries(v4Filters)) {
    // Convert filter[field][op] to filter.field.op
    const match = key.match(/^filter\[([^\]]+)\]\[([^\]]+)\]$/);
    if (match) {
      const [, field, op] = match;
      v5Filters[`filter.${field}.${op}`] = value;
    } else {
      v5Filters[key] = value;
    }
  }

  return v5Filters;
}
```

#### Response format changes

```javascript  theme={null}
// v4 response wrapper
{
  "success": true,
  "data": [...],
  "meta": {
    "total": 100,
    "page": 1
  }
}

// v5 response (direct array)
[
  { "id": "con_123", "email": "john@example.com" },
  { "id": "con_456", "email": "jane@example.com" }
]

// Migration adapter
function adaptV4Response(v5Response, endpoint) {
  if (endpoint.includes('/count')) {
    return v5Response; // Count endpoint unchanged
  }

  if (Array.isArray(v5Response)) {
    return {
      success: true,
      data: v5Response,
      meta: {
        count: v5Response.length
      }
    };
  }

  return {
    success: true,
    data: v5Response
  };
}
```

## Testing version compatibility

### Version-specific test suite

```javascript  theme={null}
describe("API Version Compatibility", () => {
  const versions = ["v4", "v5"];

  versions.forEach((version) => {
    describe(`API ${version}`, () => {
      let client;

      beforeEach(() => {
        client = new FirstQuadrantClient({
          apiKey: process.env.TEST_API_KEY,
          version,
        });
      });

      it("should fetch contacts", async () => {
        const contacts = await client.getContacts({
          status: "active",
        });

        expect(contacts).toBeDefined();
        // Version-specific assertions
        if (version === "v4") {
          expect(contacts).toHaveProperty("data");
        } else {
          expect(Array.isArray(contacts)).toBe(true);
        }
      });
    });
  });
});
```

### Compatibility checker

```javascript  theme={null}
async function checkApiCompatibility(version) {
  const tests = [
    {
      name: "Authentication",
      endpoint: "/me",
      method: "GET",
    },
    {
      name: "List Contacts",
      endpoint: "/contacts",
      method: "GET",
    },
    {
      name: "Filtering",
      endpoint: "/contacts?filter.email.contains=@example.com",
      method: "GET",
    },
  ];

  const results = [];

  for (const test of tests) {
    try {
      const response = await fetch(`https://api.us.firstquadrant.ai/${version}${test.endpoint}`, {
        method: test.method,
        headers: {
          Authorization: `Bearer ${API_KEY}`,
        },
      });

      results.push({
        test: test.name,
        status: response.ok ? "PASS" : "FAIL",
        statusCode: response.status,
      });
    } catch (error) {
      results.push({
        test: test.name,
        status: "ERROR",
        error: error.message,
      });
    }
  }

  return results;
}
```

## Staying updated

### API changelog

Monitor changes through:

1. **Changelog**: [docs.firstquadrant.ai/changelog](https://docs.firstquadrant.ai/changelog)
2. **Email Notifications**: Subscribe to API updates
3. **Version Header**: Monitor the `Version` header for changes

### Webhooks for version changes

Subscribe to version change notifications:

```javascript  theme={null}
{
  "event": "api.version.deprecated",
  "version": "v4",
  "deprecationDate": "2024-06-01",
  "endOfLifeDate": "2024-12-31",
  "migrationGuide": "https://docs.firstquadrant.ai/migration/v4-to-v5"
}
```

## Best practices

### 1. Explicit version declaration

Always explicitly specify the API version:

```javascript  theme={null}
// ✅ Good: Explicit version
const API_VERSION = "v5";
const API_BASE = `https://api.us.firstquadrant.ai/${API_VERSION}`;

// ❌ Bad: Implicit latest version
const API_BASE = "https://api.us.firstquadrant.ai/latest";
```

### 2. Version configuration

Make version configurable:

```javascript  theme={null}
// config.js
export const config = {
  api: {
    version: process.env.FIRSTQUADRANT_API_VERSION || "v5",
    key: process.env.FIRSTQUADRANT_API_KEY,
    baseUrl: process.env.FIRSTQUADRANT_API_URL || "https://api.us.firstquadrant.ai",
  },
};
```

### 3. Gradual migration

Implement feature flags for version migration:

```javascript  theme={null}
class VersionedClient {
  async getContacts(params) {
    if (featureFlags.useV5Api) {
      return this.v5.getContacts(params);
    } else {
      return this.v4.getContacts(params);
    }
  }
}
```

### 4. Monitor version usage

Track which versions your application uses:

```javascript  theme={null}
class APIClient {
  constructor() {
    this.metrics = {
      versionUsage: {},
    };
  }

  async request(version, endpoint) {
    // Track version usage
    this.metrics.versionUsage[version] = (this.metrics.versionUsage[version] || 0) + 1;

    // Make request
    const response = await fetch(`https://api.us.firstquadrant.ai/${version}${endpoint}`);

    // Log version from response
    console.log(`Used API ${version}, Server: ${response.headers.get("Version")}`);

    return response;
  }
}
```

## Summary

* **Current Version**: v5
* **Version in URL**: `https://api.us.firstquadrant.ai/v5`
* **Version Header**: Included in all responses
* **Support Period**: 12+ months after deprecation
* **Migration Notice**: 6 months before changes
* **Best Practice**: Always use explicit versioning

Stay informed about version changes and plan migrations early to ensure smooth transitions between API versions.


# Action list
Source: https://docs.firstquadrant.ai/getting-started/actions

The actions list in FirstQuadrant is a dynamic AI-powered task manager that replaces traditional CRM pipelines. It surfaces only the most relevant next steps for your deals, allowing you to review, approve, or adjust AI-suggested actions and maintain a clean, focused sales workflow.

## Overview

At the core of FirstQuadrant’s experience is the **actions list** — your command center for daily sales activity. Unlike traditional CRMs that rely on kanban-style pipeline views, FirstQuadrant streamlines everything into a single, intelligent list of AI-generated tasks that guide your sales execution.

## What is the actions list?

The actions list is a dynamically generated to-do list created by FirstQuadrant’s AI. It surfaces only the tasks that require your input or approval. Each item in the list represents a suggested next step in your sales pipeline — planned and proposed by the system based on ongoing signals and context.

### Examples of triggers that generate action items

* A new inbound email is received.
* A contact schedules a call.
* A prospect visits your website or signs up via a connected form.
* A deal becomes stale.
* A calendar event is occurring and notes should be added.

Once a signal is detected, FirstQuadrant reasons about it and creates a proposed next step, such as following up, scheduling a call, or sending a pricing PDF.

These tasks are then added to your actions list — for you to quickly approve, reject, or modify.

## How to use the actions list

### 1. Start your day here

Open the app, and your actions list will greet you. This list replaces the need to manually dig through your CRM pipeline or email threads.

### 2. Review each task

Click into any item to see more details. You’ll see the context (contact, company, past interactions), proposed action, associated tags (like “Follow-up”, “Scheduling”, “Note”), and the suggested communication.

### 3. Approve or edit

If the suggestion is correct, approve it and FirstQuadrant will execute the next step. If not, you can edit or override it. This collaboration between you and the AI keeps your pipeline moving without micromanaging.

### 4. Maintain inbox zero

Think of the actions list as your "Inbox Zero" for sales. At the end of the day, if the list is empty, you can be confident that no important sales conversations or follow-ups are left unattended.

## Why FirstQuadrant removes the pipeline view

FirstQuadrant intentionally removes traditional CRM pipeline boards. Instead of forcing you to maintain and update a rigid visual structure, we let the AI handle pipeline logic in the background and surface only the actions that matter to you.

This removes cognitive overhead and helps you stay focused on doing the work, not organizing it.


# Adding new contacts
Source: https://docs.firstquadrant.ai/getting-started/adding-new-contacts

This guide explains how to continuously add new contacts to FirstQuadrant, whether manually or through automated inbound and outbound workflows. It covers manual entry, web form automation, self-serve signup qualification, and integrations with external tools—ensuring that every sales opportunity enters the pipeline and is managed effectively by the AI.

## Overview

Once you've imported all existing contacts into FirstQuadrant—both active and inactive—it's essential to ensure that new sales opportunities are continuously captured and added to your workspace. FirstQuadrant offers multiple ways to add new contacts, whether manually or through automated workflows for both inbound and outbound campaigns.

## Adding contacts manually

### Use the “New contact” button

At any point, you can add a new contact manually by clicking the **“New contact”** button at the top left of your FirstQuadrant interface. This is useful for quickly capturing a lead you just interacted with or someone who reached out directly.

## Suggested imports

FirstQuadrant proactively helps you identify new contacts by automatically analyzing incoming emails. When it detects a sales-related message, it creates a **suggested import** to import the sender as a new contact. This ensures no opportunity slips through the cracks and reduces manual effort in maintaining your contact list. You can [manage suggested import settings](/product-manual/workspace-settings/suggested-imports) to control how these recommendations appear.

## Automating inbound contact creation

### Web form submissions

FirstQuadrant allows you to automatically create contacts from your **website forms**. For example:

* When someone fills out a **Contact Us** or **Request a Demo** form, a new contact can be created automatically.
* FirstQuadrant can then immediately start managing the conversation: answering questions, scheduling meetings, and routing the deal through your inbound pipeline.

### Self-serve signups

If you have a **product-led growth** motion with self-serve signups, you can use FirstQuadrant to:

* Automatically add all new signups as contacts
* Qualify them using custom rules or AI-based criteria
* Focus your sales attention only on high-potential accounts

## Generating top-of-funnel via outbound

FirstQuadrant is not only useful for managing existing deals—it can also **generate new sales opportunities** from scratch. You can:

* Run outbound campaigns directly inside FirstQuadrant
* Use built-in tools for **contact enrichment** and **qualification**
* Send personalized outreach emails at scale

If you’re using external outbound tools already, FirstQuadrant can also integrate into your existing stack by:

* Catching replies from external campaigns
* Automatically creating and managing these conversations inside FirstQuadrant

## Playbooks

The best way to learn about all these methods is through the **[Playbooks](/playbooks)** section. There you'll find:

* Step-by-step guides on inbound automation
* Outbound campaign setup instructions
* Tactics for identifying website visitors and turning them into leads
* Instructions for integrating with external tools and syncing replies

These guides help you tailor your lead acquisition strategy to your specific workflow and ensure every new opportunity is captured and managed efficiently.

## Best practices

* Select core flows from the playbooks that match your sales motion
* Implement automation wherever possible to minimize manual data entry
* Train all team members on how new contacts enter FirstQuadrant to prevent funnel leakage

Once contacts are in FirstQuadrant, the AI will ensure they are engaged at the right time and with the right messaging, helping you drive deals forward automatically.


# Importing existing contacts
Source: https://docs.firstquadrant.ai/getting-started/importing-existing-contacts

This guide walks users through importing existing contacts into FirstQuadrant by segmenting them into active and inactive categories. It outlines why contact imports are essential for AI-driven automation, explains how to prepare CSV files, and details each step of the import process. It also provides best practices for configuring import schedules and conserving AI credits, ensuring FirstQuadrant can effectively manage sales follow-ups and reactivation efforts.

## Why importing contacts is critical

FirstQuadrant only processes and reasons about emails related to contacts that are stored in its database. Without imported contacts, FirstQuadrant will ignore relevant communication in your inbox and miss opportunities to drive your sales pipeline forward.

To make full use of FirstQuadrant's automation, you should first import your existing contacts by segmenting them into two buckets (learn more about [active and inactive contacts](/product-manual/active-inactive-contacts)):

### Active contacts

These are people you are currently engaged with. This includes:

* Conversations where you're waiting on a reply
* Conversations where a follow-up is scheduled
* Contacts with a planned check-in months down the line

If you're using a CRM, these contacts usually have open deals associated with them. If you’re not using a CRM, look at your inbox or spreadsheets.

### Inactive contacts

These are older leads or prospects you're not actively speaking to but have engaged with in the past. While there's no immediate follow-up required, you’ll want to re-engage them over time through FirstQuadrant’s nurturing workflows.

***

## Step-by-step: How to import contacts

### Step 1: Navigate to the import section

* In the left-hand sidebar, scroll down and click on **Imports**
* In the top-right corner, click **New import**
* Choose **Upload** to import contacts from a CSV file

### Step 2: Prepare your CSV

* Download the **example CSV** from the import screen
* Format your file to match the column headers (e.g., full name, email, company, LinkedIn handle)
* The only required field is **email**, but adding name and company improves accuracy

### Step 3: Map the columns

* Once you upload your CSV, you'll be prompted to **map each column** to a corresponding property (e.g., map "LinkedIn Handle" to the appropriate field)
* After mapping, click **Upload rows**

### Step 4: Configure import settings

#### For active contacts

* **Name** your import (e.g., "Active contacts")
* **Skip qualifying questions** (optional for active contacts)
* Leave qualifying rules at default
* Under **Schedule**, select "Import all rows immediately"
* Click **Save, start import, and enrich**

#### For inactive contacts

* Follow the same process, but:
  * **Name** the import (e.g., "Inactive contacts")
  * Under **Schedule**, select "Import on a recurring schedule"
  * Choose a lower batch size (e.g., 100 or 1,000 rows/month) to conserve AI credits
  * Click **Save changes**

> **Info:** Check out the [imports overview article](/product-manual/imports/imports-overview) for a more detailed explanation and step-by-step instructions

***

## Additional tips

* Add a **note** to the import if you'd like FirstQuadrant to apply specific behavior (e.g., "These are active leads—take immediate action")
* Contacts are enriched and synced with your email history upon import
* You can pause, edit, or delete an import draft at any time

By segmenting contacts and importing them thoughtfully, you enable FirstQuadrant to act intelligently and continuously drive value throughout your sales cycle.


# Introduction
Source: https://docs.firstquadrant.ai/getting-started/introduction

FirstQuadrant is an AI-powered B2B sales platform designed to support your entire revenue team in managing deals, handling sales conversations, nurturing business relationships, and driving top-of-funnel pipeline. It’s a powerful and flexible system that can adapt to nearly any sales use case you might have in mind. But to unlock its full potential, it’s important to understand how it actually works under the hood.

## FirstQuadrant is not rule-based—it’s decision-based

At the core of FirstQuadrant lies a dynamic AI system that continuously makes intelligent decisions on your behalf. Unlike traditional automation platforms that rely on rigid workflows or decision trees (e.g., "if this, then that" logic), FirstQuadrant takes a more human-like, context-aware approach.

### What drives the AI's decisions?

The AI engine in FirstQuadrant makes decisions based on three foundational pillars:

1. **Conversation history**\
   Every message exchanged with a contact is taken into account. The AI understands what has been said, what was promised, what was ignored, and what might need a follow-up.
2. **Contact context**\
   This includes who the contact is, their company, custom properties you've added, their role, pipeline stage, historical interactions, and more. All of this helps the AI understand the broader relationship context.
3. **[Settings and fine-tunings](/product-manual/fine-tuning/fine-tuning-overview)**\
   You have control over how the AI behaves. Through fine-tuning options and custom instructions, you can shape its tone, priorities, and decision-making rules. These are not rigid scripts, but guiding principles that the AI considers when choosing its next step.

## The AI continuously adapts to new information

Whenever something happens with a contact—an email comes in, a note is added, a form is filled, or a signup is recorded—FirstQuadrant immediately takes that new piece of data into account and dynamically re-evaluates its strategy. It always plans ahead with the information currently available.

For instance, the AI may have previously planned a reply and a sequence of follow-ups. But as soon as a new email arrives, that entire plan is automatically discarded. The AI starts fresh, incorporating the latest input to create a new, optimized path forward.

This continuous cycle of sensing, evaluating, and replanning enables a highly flexible approach to handling sales conversations. It ensures that the next steps are always relevant, timely, and based on the most up-to-date information available.

## Why FirstQuadrant doesn’t rely on static workflows

Traditional sales automation tools require you to manually create static workflows and logic trees. But sales conversations are rarely predictable—leads respond late, go dark, change roles, or ask unexpected questions. Static workflows can’t handle this level of complexity without becoming brittle and difficult to maintain.

FirstQuadrant, by contrast, adapts dynamically. The AI assesses the real-time situation and determines the best course of action without relying on pre-defined paths. This allows it to:

* Follow up when a response is missed
* Rephrase or retry when an email is ignored
* Reference past conversations when reaching back out
* Personalize its tone or content based on the relationship history

## Customization = Training your assistant

Customizing FirstQuadrant doesn’t mean writing logic rules. Instead, think of it as **training an intelligent assistant**:

* You tell it how you generally want things done
* You fine-tune the behavior with examples and guidelines
* Then you let it apply good judgment in nuanced situations

The assistant might sometimes bend or override your instruction if the situation calls for it—because it's trying to help you succeed, not just follow orders blindly.

## What this means for you

Once you understand this core system, FirstQuadrant becomes a powerful extension of your team. You can:

* Launch fully automated outreach without scripting every response
* Trust the platform to follow up intelligently and at the right time
* Customize its behavior without getting lost in complex logic trees

There are virtually unlimited possibilities. But it all starts by shifting your mindset: You’re not programming a tool. You’re training an assistant.


# Quickstart 
Source: https://docs.firstquadrant.ai/getting-started/quickstart

This guide walks new users through the essential setup steps in FirstQuadrant, including adding team members, connecting email and calendar accounts, and configuring the sales pipeline to align with their sales process.

### Overview

When you first sign up for FirstQuadrant, you're greeted by a clean, empty interface. To begin using the platform effectively, you'll need to complete a few essential setup steps. This guide walks you through setting up your team, email and calendar integrations, and customizing your sales pipeline to start managing your sales process intelligently.

***

## 1. Add your team members

Navigate to **Settings → Workspace → Members**.\
Here you can add all team members who will be using FirstQuadrant.

* Click **New membership** to add a user.
* Once a team member is added, click their name to enter their default **scheduling link** (e.g. Calendly, cal.com).\
  This ensures that whenever FirstQuadrant needs to schedule a meeting on their behalf, it uses the correct URL.

***

## 2. Connect email accounts

Go to **Settings → Integrations → Email accounts**.\
Each team member can connect one or more mailboxes:

* Supported providers: **Google Workspace**, **Microsoft Office 365**, **Microsoft Exchange**, or **SMTP** via **Other**.
* Begin by connecting your **primary email account**—typically the one used for most daily communication.
* Then connect any **secondary outbound email accounts**.
* There is **no limit** to the number of email accounts per user, so connect all relevant addresses.

> **Important:** For Google Workspace accounts, you need to **add FirstQuadrant as a trusted developer** before proceeding. Check out the [help desk article](/product-manual/integrations-settings/add-as-trusted-developer-google-workspace).

***

## 3. Connect calendar accounts

Go to **Settings → Integrations → Calendar accounts**.\
This step allows FirstQuadrant to access availability and detect when sales meetings are scheduled.

* Connect your calendar via **Google**, **Microsoft**, or another provider.
* Ensure each team member has their calendar connected for accurate scheduling and meeting tracking.

***

## 4. Set up your pipeline

Go to **Settings → Workspace → Pipelines**.\
A default pipeline is created for you automatically, but you can customize or add more.

* Click on the pipeline name to open the pipeline editor.
* Set the **description** of the pipeline to clarify what type of deals it handles (especially useful if you have multiple pipelines).
* Define a **default value** for new deals.\
  You can enter natural language formulas like:\
  *"Number of seats × \$1,000"*\
  FirstQuadrant will use this formula to automatically calculate and estimate deal sizes.

### 4.1 Customizing stages

Each pipeline contains stages. Click into a stage to configure:

* **Name** and **description**: These help the AI understand what kind of deals belong in each stage.
* **Goal**: Define what should happen for a deal to progress to the next stage (e.g., "Prospect books a discovery call using our scheduling link").

You can:

* Use the **default scheduling link per team member**, or
* Provide a **custom scheduling URL** for the stage.

***

### Final steps

By following these steps, your workspace will be fully configured and ready to leverage FirstQuadrant’s AI to manage your sales pipeline dynamically and intelligently.


# Adding conference attendees to FirstQuadrant
Source: https://docs.firstquadrant.ai/playbooks/conference-attendees

When attending conferences, it's important to quickly capture the sales potential of new contacts. FirstQuadrant makes it easy to add conference attendees—either manually, one by one, or in bulk using a CSV upload. Here's how to do both.

## Manually adding contacts during the event

If you're meeting people throughout the day, the fastest way to log a contact is by using the **"New contact"** button at the top left of the interface.

### Steps:

1. Click **New contact** in the sidebar.

2. Enter at least an **email address** (this is required).

3. Optionally, add a **note**—for example:

   ```
   Met John at the Las Vegas conference. He’s interested in a demo in 3 weeks.
   ```

4. Click **Create contact**.

> Based on the note you add, FirstQuadrant will automatically determine the right next actions—such as scheduling a follow-up in 3 weeks.

***

## Bulk importing conference attendees

If you collected many contacts through a signup form or other source, you can upload them in bulk.

### Steps:

1. Navigate to **Imports** in the sidebar.
2. Click **New import** (top-right).
3. Choose **Upload** and select your CSV file.
4. In the import settings:
   * Skip qualifying questions unless you're filtering attendees.
   * Toggle **Import contacts as Active** if you want FirstQuadrant to engage with them right away.
   * Add a general **note** for all contacts (e.g., “Met at Las Vegas conference – follow up”).
   * Or, include a **column with individual notes** in your CSV. FirstQuadrant will automatically assign those notes to the respective contacts.
5. Click **Start import and enrich**.

> Including detailed notes in your CSV allows FirstQuadrant to personalize next steps for each attendee, even in a bulk import.

## Tips

* Use manual entry during the event for high-priority contacts with custom follow-ups.
* Use CSV import after the event to upload all booth visitors or form signups.

For more information about import setup and enrichment rules, refer to the respective guides


# Email deliverability setup
Source: https://docs.firstquadrant.ai/playbooks/email-deliverability-setup

This guide explains how to set up a reliable email deliverability system when using FirstQuadrant for outbound email campaigns. It outlines the risks of poor deliverability, how to use separate domains and mailboxes, and how to calculate the number of mailboxes required. You’ll also find best practices for warming up email addresses and maintaining your sender reputation, including recommended services and configuration steps within FirstQuadrant.

When using FirstQuadrant to send outbound email campaigns, it is crucial to establish a solid email deliverability setup. This ensures that your emails do not get blocked and reach your recipients' inboxes.

## Risks of poor email deliverability

If you send mass emails from your primary email address without proper setup, you risk triggering spam filters. This can lead to your email address—and eventually your entire domain—being marked as spam. Once this happens, none of your emails, including non-outbound ones, will land in inboxes.

To prevent this, a well-structured email deliverability setup is essential. This involves using separate domains and email addresses for outbound emails.

## FirstQuadrant's email capabilities

FirstQuadrant allows you to add unlimited email addresses per team member, making it easy to scale your outreach while maintaining high deliverability.

## Email deliverability setup overview

A strong deliverability setup consists of:

* Separate domains and email addresses for sending outbound emails
* Continuous email warming to establish sender reputation

## Setting up new domains and email addresses

You can either:

* Set up new domains and mailboxes manually through your domain registrar and Google Workspace
* Use a dedicated service like Zapmail.ai (highly recommended for efficiency and first-class FirstQuadrant integration)

### Manual setup steps (skip if setup is done through Zapmail.ai)

#### 1. Purchase new domains

These domains should resemble your primary domain. Example:

* If your primary domain is `example.com`, new domains should be similar, such as `tryexample.com`
* Redirect these new domains to your primary domain to ensure brand consistency

#### 2. Create new mailboxes (Not aliases)

Each mailbox should have different permutations of your name:

* Example: `john.doe@tryexample.com`, `john@tryexample.com`, `jd@tryexample.com`

## Calculating mailbox and domain needs

A fully warmed-up mailbox should send no more than 20-25 emails per day (conservative estimate). This is also the default setting in FirstQuadrant. To change the daily sending max:

1. Navigate to Settings > Integrations > [Email accounts](/product-manual/integrations-settings/email-accounts)
2. Click on the respective mailbox address

### How to calculate required mailboxes

Formula: `Total emails per month ÷ 25 work days ÷ 20 emails per day = Required mailboxes`

Additional considerations:

* Add 20-30% extra mailboxes for backup in case of deliverability issues
* Best practice: 4-5 mailboxes per domain

> **Info:** To calculate the real costs of your outbound campaigns read our article on the [true cost of outbound emails at scale](/playbooks/outbound-costs)

### Example calculation

* Target emails per month: 5,000
* Calculation: `5,000 ÷ 25 days ÷ 20 emails per day = 10 mailboxes`
* Backup (30%): 13 mailboxes total
* Domains needed: `13 mailboxes ÷ 4 mailboxes per domain = 3 new domains`

Once you've set up the different mailboxes you need to connect and add them to FirstQuadrant.

## Email warming process

Once mailboxes are set up, warming them up with a dedicated warming service is essential. This process makes your email accounts appear active and legitimate, reducing spam filter risks.

### Recommended email warming services

We advise using dedicated email warming services, rather than platforms that bundle warming with other features, as dedicated services provide better infrastructure and results. A good warming service we've used in the past is `mailreach.co`

### Warming process guidelines

1. **Duration**: Warm up mailboxes for at least 2 months before full-scale outbound campaigns
2. **Gradual Increase**: Start with low email volume and slowly increase over time
3. **Ramp-up Period**: Adjust ramp-up settings in FirstQuadrant to control email volume
   * Navigate to: Settings > Integrations > [Email accounts](/product-manual/integrations-settings/email-accounts)
   * Select the outbound email and adjust the default ramp-up period of 35 days
   * Set to 0 if no ramp-up is required

By following these steps, you will ensure optimal email deliverability, maximizing your outbound email success while safeguarding your domain reputation.


# FirstQuadrant for inbound leads 
Source: https://docs.firstquadrant.ai/playbooks/inbound-leads

Learn how to automatically import and qualify inbound leads from your website into FirstQuadrant—whether they signed up via a form, self-serve flow, or demo booking. This guide covers webhook setup, Zapier integration, qualification logic (both pre- and post-import), AI enrichment, and fine-tuning rules to personalize follow-ups based on lead attributes.

This article explains how to automatically add new leads to FirstQuadrant based on their behavior on your website. There are three common ways new leads enter your pipeline:

1. **Website form submissions**
2. **Self-serve product signups**
3. **Demo bookings through scheduling tools like Calendly or cal.com**

We'll walk through how to connect each of these to FirstQuadrant in detail.

***

## 1. Website form submissions

If someone fills out a form on your site (e.g. "Contact Us" or "Get a demo"), you can use FirstQuadrant's webhook integration to automatically import their data.

### How to set it up

1. Go to **[Imports](/product-manual/imports/imports-overview)** in the FirstQuadrant sidebar.
2. Click **New Import** and select **Webhook/API**.
3. A new webhook URL will be generated. Copy this URL.
4. Configure your form handler (e.g. Webflow, Typeform, custom backend) to send a `POST` request to this URL.
5. The payload should be a JSON object that includes at least the contact’s email. Example:

```
{
  "contact": {
    "email": "jane.doe@example.com"
  }
}
```

6. You can also include additional optional fields:
   * `note` (free-text): e.g. "Filled out website form requesting a demo and said …."
   * `company` details: name, domain, location
   * `employment`: title, job level, etc.

All fields will be enriched by FirstQuadrant where applicable.

> **Tip**: Use the `note` field to give the AI extra context. For example: *"Signed up via contact form. Please follow up with demo scheduling link."*

> **More on Webhooks:** For a complete breakdown of how to send data to FirstQuadrant using webhooks—including supported fields, advanced payload formats, authentication, and retry behavior—refer to our dedicated [Webhook Import Documentation](/product-manual/imports/webhooks).

***

## 2. Self-serve signups

If your product allows users to sign up and onboard without human intervention, you can treat these users the same as website form submissions:

### How to set it up

1. Create a webhook import under **Imports**.
2. Send the same basic JSON payload when a signup is created.
3. Include a `note` that reflects their signup behavior. For example:
   * "Signed up for self-serve onboarding"
   * "Signed up but dropped off at step 3"

Providing a note gives the AI important context about what just happened and what should happen next. For example, you could write something like: "Signed up via self-serve, dropped off at step 3 of onboarding." This allows FirstQuadrant to adapt its actions accordingly—whether that means sending a follow-up email, offering help, or triggering a task.

You can resend the webhook multiple times with updated notes if the same contact takes new actions (e.g., progresses further in onboarding).

> **Tip:** You don't need to build complex workflows. Just describe what happened in plain language, and the AI will figure out the next best steps on its own.

***

## 3. Demo bookings via Calendly, cal.com, or similar

If users book a demo directly through a scheduling link on your website, you can use Zapier to automatically add those contacts to FirstQuadrant.

### How to set it up in Zapier

1. Go to Zapier and create a new Zap.
2. **Trigger**:
   * App: Calendly (or your preferred tool)
   * Event: Invitee Created
3. **Action**:
   * App: FirstQuadrant
   * Event: Create Contact
4. Map at least the email field.
5. Optionally, add a note: "Booked demo via website scheduling link"

FirstQuadrant has a native integration with Cal.com, so you can also use that instead of Zapier.

> **Note**: Even without a note, FirstQuadrant can infer context from the calendar integration if the event shows up on your calendar.

***

## What happens after import: qualification and next steps

Once a contact is successfully imported—whether from a form, a self-serve signup, or a demo booking—FirstQuadrant automatically plans the next steps. This involves determining whether to engage, how to engage, and when. To control and customize this behavior, there are two primary strategies for qualifying and acting on inbound leads:

### Option A: Pre-import qualification

This approach allows you to define upfront rules that filter out low-quality or irrelevant contacts before they are ever added to FirstQuadrant. You set these rules in the **Import Settings** for each webhook or file upload.

There are two layers of filtering available:

1. **Basic filters** (checkbox toggles):
   * Company website must be available
   * Email address must be verified
   * Must be a professional (non-free) email
   * Skip importing existing contacts
2. **Qualification questions**: You can also ask specific questions to qualify leads more rigorously. For example:

   * Is this company in the software industry?
   * Does this person have a senior-level title?

   These questions work by querying perplexities AI search and can be used to determine whether a lead should be allowed into your workspace. Only leads that pass all criteria will be imported and acted upon by the AI.

If a contact does not meet all criteria, they are ignored completely. This is ideal when you want tight control over what enters your pipeline or want to avoid using up AI credits on unqualified leads.

> **Keep in mind:** Disqualified contacts are never visible in FirstQuadrant. The system does not track or process them. You can check out the qualified/disqualified contacts in the import detailed view, however.

> **Need help configuring imports?** Visit our detailed [Import Helpdesk Articles](/product-manual/imports/import-settings) to learn more about the import and qualification process.

***

### Option B: Post-import qualification

This approach gives you maximum flexibility: you allow all contacts to enter FirstQuadrant without applying any qualification criteria in the import settings. Instead, you enrich and segment the leads after they’re imported using **AI-enriched properties** and **fine-tuning rules**.

> **Important:** In this setup, you should leave the qualification section in the import settings blank. All leads will be imported as-is, and qualification will happen entirely through enriched properties and AI-based logic.

#### Step-by-step example

Let’s say you want to take different actions based on the company size of the lead—for example, prioritize enterprise leads over small businesses. Here’s how you’d set that up using properties and fine-tuning rules, entirely **after the import happens**:

1. **Create a custom property**
   * Navigate to **Settings > [Properties](/product-manual/properties/properties)**
   * Click **New Property**
   * Choose the **Company** record type (since headcount is a company-level attribute)
   * Set the property type to **Number**
   * Name the property (e.g., `Company Headcount` or `Employees`)
   * Enable **AI enrichment** and select **Perplexity** as the data source Once saved, FirstQuadrant will automatically enrich this property by pulling the company’s headcount from trusted sources via Perplexity, typically within a few seconds after the contact is imported.

> **Need help creating properties?** Learn how to create and configure custom properties, including enabling enrichment with AI and linking to contact or company records in our [Properties Help Guide](/product-manual/properties/properties).

1. **Create a fine-tuning rule to act on that property**

   * Go to **Settings > [Fine-tuning](/product-manual/fine-tuning/fine-tuning-overview)**
   * Click **New Rule** and choose **General Rule**
   * In the "Applies to" section, select only the relevant import segment, such as your specific webhook-based import or form-based signup feed. This ensures the rule only applies to leads coming through that import.
   * In the instruction text, describe what should happen based on the company headcount. For example:

     ```
     When the company has more than 500 employees, send them an email with a direct demo scheduling link immediately.
     When the company has less than 500 employees, send them a message offering support during the self-serve setup.
     ```

This setup allows FirstQuadrant to interpret real company context and determine the best next step for each lead. You don’t need to pre-filter anything. Every lead comes in, but how FirstQuadrant responds varies based on AI-enriched attributes.

**New to fine-tuning rules?** Learn how to write clear, context-based rules to guide the AI's behavior in our [Fine-Tuning Guide](/product-manual/fine-tuning/create-fine-tuning).

> **Pro tip**: This method is especially powerful when your lead pool is diverse. Let the AI sort and adapt the messaging based on the data it enriches. You can also continue layering in additional rules over time as you refine your workflows.

> **New to fine-tuning rules?** Learn how to write clear, context-based rules to guide the AI's behavior in our [Fine-Tuning Guide](/product-manual/fine-tuning/create-fine-tuning).

You can combine this with basic import filters (Option A) if you want to pre-gate obviously unqualified leads (e.g., no professional email, no domain), and then use these enriched rules to personalize the response after that.

***


# Handling meeting cancellations and no-shows
Source: https://docs.firstquadrant.ai/playbooks/meetings-cancelled

FirstQuadrant allows you to automatically or manually respond when a scheduled meeting gets canceled or the other party doesn’t show up. This ensures your sales follow-ups continue without disruption.

## Calendar connection required

To enable automated handling of cancellations, make sure your calendar is connected to FirstQuadrant. You can do this in the **Settings > Integrations > Calendar accounts** section.

> **Info**: Need help connecting your calendar? See calendar integration article for step-by-step instructions.

## If the meeting is canceled

If the meeting is canceled ahead of time (e.g., the invitee cancels the calendar event), FirstQuadrant will detect this via the connected calendar and will:

* Trigger a follow-up sequence, prompting the invitee to reschedule

This happens without manual intervention.

## If the person doesn’t show up (no-show)

If the meeting is not canceled but the invitee simply doesn’t show up:

1. Navigate to the contact’s page in FirstQuadrant
2. Click **“Take a note”**
3. Type `no-show` at optionally additional instructions what to do and click **Create note**

That’s it. FirstQuadrant will now understand that the meeting was a no-show and will trigger an appropriate follow-up, typically asking the contact to reschedule.

## What happens next

Once informed of a cancellation or a no-show, FirstQuadrant will automatically decide the best next steps, typically by:

* Sending a polite reschedule email
* Updating your action list if a manual step is needed
* Ensuring the deal continues progressing in your pipeline


# How to run an outbound campaign from start to finish in FirstQuadrant
Source: https://docs.firstquadrant.ai/playbooks/outbound-campaign

FirstQuadrant supports complete outbound campaign execution — from email infrastructure setup to targeted prospecting, automated sequences, and performance analytics. This guide walks you through every detail of launching and running outbound entirely within FirstQuadrant.

## 1. Set up your outbound email infrastructure

### Add dedicated outbound email accounts

To run outbound at scale, you need multiple mailboxes. This is critical for deliverability. Most email providers, especially Google and Microsoft, restrict sending volumes to around 20–40 emails per day per mailbox to prevent spam. To send high volumes (e.g. 10,000+ emails/month), you will need multiple fully independent email accounts. These must be actual Google Workspace or Microsoft Office accounts — aliases and shared mailboxes will not work.

**Info**: To calculate how many email accounts you'll need for your outbound campaign, refer to our detailed Email Account Sizing Guide. It includes benchmarks based on daily volume goals, warming constraints, and deliverability best practices.

### Warm up each email account

Email warming is mandatory. Sending cold emails from fresh accounts without warming is guaranteed to land your emails in spam. Warming simulates natural email behavior — sending, receiving, and replying to emails — to build trust with spam filters.

We recommend MailReach, though any professional warming provider will work. Once connected, warming providers automatically send emails to other mailboxes they control and reply back, thus simulating realistic engagement.

There are two phases to warming:

* **Initial warming period** (before you start outbound): Run warming for 6–8 weeks before sending real emails.
* **Ongoing warming** (during outbound): Continue warming indefinitely to maintain a healthy sending reputation.

### Connect your email accounts to FirstQuadrant

Once your outbound email accounts are fully warmed up and configured, connect each one to FirstQuadrant.

You can add an unlimited number of email accounts to your workspace. This is particularly important for high-volume sending, as FirstQuadrant will intelligently rotate senders across your configured accounts to stay within daily sending thresholds.

To connect:

* Navigate to **Settings → Integrations → [Email Accounts](/product-manual/integrations-settings/email-accounts)**
* Click **Connect email account** and follow the authentication flow for Google Workspace, Microsoft Office 365, Exchange, or other supported providers
* After connecting, assign the email account to the correct team member (this affects signature, sender name, and ownership)
* Make sure the correct sending configuration (daily limit, ramp-up, content identifier, reply-to) is defined for each mailbox in **Advanced Settings**

Every connected mailbox must be properly configured before launching campaigns to ensure performance and deliverability.

### Add content identifier to exclude warming emails

In FirstQuadrant, go to **Settings → Integrations → [Email Accounts](/product-manual/integrations-settings/email-accounts)** and select your outbound account. Under **Advanced Settings**, add the content identifier used by your warming tool. This tells FirstQuadrant to ignore those warming emails. If you skip this step, warming emails will pollute your inbox with irrelevant contacts, and you'll waste AI credits on sequences that are not meant to be sent.

### Configure sending limits and ramp-up duration

Still in **Advanced Settings**, set:

* **Daily sending limit:** Define the max number of emails this account can send in one day (e.g. 20–40).
* **Ramp-up duration:** Set to 35 days to gradually increase sending from 0 to your defined daily limit. This protects your domain reputation and prevents sudden spam flags.

You can also set the **reply-to address**, a **minimum wait time** between emails, and overwrite the suggested imports behavior on a per-email basis.

**Info:** Refer to the **Email Deliverability Guide** for full best practices on DNS setup, domain strategy, and mailbox hygiene.

***

## 2. Build your prospecting audience

### Use third-party prospecting tools

Once your infrastructure is ready, the next critical step is to define who you're reaching out to — your target audience. This is arguably the most important part of any outbound campaign. If you get your prospecting wrong, no amount of great copy or email infrastructure can save the campaign.

FirstQuadrant does not have built-in prospecting. Instead, you can use any third-party prospecting tool such as:

* **Apollo.io** - Filter by job title, company size, industry, location, funding stage, and more
* **ZoomInfo** - Comprehensive B2B contact and company database
* **LinkedIn Sales Navigator** - Professional network-based prospecting
* **Hunter.io** - Email finder and verifier
* **Lusha** - Contact and company data platform

### Import your prospects via CSV

After building your prospect list in your chosen tool, export the data as a CSV file and import it into FirstQuadrant:

1. Go to **[Imports](/product-manual/imports/imports-overview)**
2. Click **New import → CSV**
3. Upload your exported CSV file
4. Map the columns to FirstQuadrant's contact fields
5. Review and confirm the import

**Info**: For a detailed walkthrough of how to import contacts via CSV — including column mapping, data validation, and best practices — refer to our [CSV Uploads Guide](/product-manual/imports/csv-uploads).

### Configure import settings and qualification

Once your filters are set, you’ll move to the **Import Settings** screen. This is where you fine-tune the quality of your audience — and it’s where most of the real value is generated.

#### Why qualification matters

Outreach is expensive: you only have limited bandwidth, reputation, and credits to reach the right people. The qualification layer ensures that you're not just importing contacts who look like a fit on paper, but that they actually meet deeper criteria unique to your ICP.

Adding multiple layers of qualification at this stage leads to significantly better conversion rates later on.

#### Qualification questions

These are custom logic questions that FirstQuadrant's AI will research using Perplexity for every contact before importing them. For example:

* "Has the company raised funding in the last 2 years?"
* "Does the company have a product-led growth motion?"
* "Does the website mention a partner program?"
* “Is this a B2B saas?"
* “Are they remote friendly” etc.

#### Qualification rules

In addition to open-ended questions, we strongly recommend enabling all default qualification rules for outbound:

* Company website is up and accessible
* Contact’s email address is verified
* The email is professional (i.e. not Gmail, Yahoo, etc.)
* Exclude any contact already in your workspace

This helps eliminate invalid or low-quality entries from polluting your campaign.

#### Import cadence

If you're dealing with large audiences, consider enabling **recurring imports** (e.g. 100 leads per month). This way, a single prospecting effort can sustain your campaign pipeline for months — no need to constantly revisit audience building.

***

## 3. Create and configure your outbound campaign

Once your audience has been carefully built and qualified, it’s time to configure and launch your outbound campaign. This is where everything comes together — your warmed-up infrastructure, your curated contact lists, and your messaging strategy.

Navigate to **[Campaigns](/product-manual/campaigns/campaign-overview)** and click **Create campaign** to begin.

### Step 1: Select senders

Start by selecting all the outbound email accounts you’ve connected. These should be fully warmed up and correctly configured.

Each mailbox will be used to distribute outbound emails in parallel, and FirstQuadrant will manage distribution across mailboxes automatically. This helps you stay within deliverability-safe limits while scaling outreach.

### Step 2: Assign your audience

Now assign the audience you imported during your prospecting and qualification steps. These contacts should already have been vetted by your qualification questions and rules.

This audience is the foundation of your campaign. Only well-qualified leads should be included here — if you’re unsure about the quality of your contacts, revisit your import settings first. Your performance downstream will depend heavily on how tight and well-qualified this audience is.

### Step 3: Create your outbound email sequence

This is where you design what your recipients will receive — the emails themselves.

Use the **Sequence Builder** to define:

* A personalized first-touch email
* Follow-up messages (typically 2–4)
* A/B variants of the sequence

**Recommendations for effective sequences:**

* Use AI personalization fields like `{first name}`, `{company name}`, `{pain_point}` — but also test how far you can push it (e.g., `{company_blog_topic}` or `{relevant_news}`)
* Test multiple sequence types:
  * **A**: Short and direct
  * **B**: Narrative-driven or story-based
  * **C**: Problem-solution framing
  * **D**: Industry-specific insight

Test a minimum of 2–4 variants so you can gather comparative data. Small changes (e.g. subject line or tone) can lead to large performance differences.

**Info:** Read the campaing guide for more detailed instructions on how to create sequences and campaign.

### Step 4: Configure campaign automation options

Under campaign settings, you can control automation levels.

We strongly recommend enabling:

* **Autopilot:** Sends emails without requiring manual approval. Crucial for scale — otherwise you'll manually approve hundreds of emails.
* **Autopilot exception for existing conversations:** Keeps Autopilot active except for contacts with a prior email history (e.g. past clients, friends). In those cases, FirstQuadrant pauses and lets you review the message before it goes out.
* **Contextual adjustment:** Allows the AI to adjust tone or wording based on historical email threads (if available).
* **Open tracking:** Turned on by default and generally should remain active for outbound campaigns.

These automation settings are especially important when managing large-scale campaigns involving thousands of emails. They ensure that FirstQuadrant handles most of the manual overhead while preserving safety checks where needed.

Once the above steps are completed, you can move on to launch — which we’ll cover next.

***

## 4. Launch and monitor your campaign

Once your campaign is configured and launched, FirstQuadrant will start sending emails based on the parameters and ramp-up settings you've defined. You can monitor performance and adjust strategy through the **[Analytics](/product-manual/analytics) → Campaigns** dashboard.

### Understand ramp-up behavior

If you’ve enabled ramp-up in the advanced email account settings (highly recommended), your campaign will begin sending at a low volume and scale up over the defined duration (usually 35 days). This protects your sender reputation and helps maintain long-term deliverability.

During this phase, you should expect relatively low daily email volume per mailbox. As volume increases, your reply rate and engagement metrics will normalize.

Additionally, keep in mind:

* Most recipients will not reply to your first message.
* Response rates usually increase after the second or third email in a sequence.
* If your follow-up delays are spaced over multiple days (e.g. 3–5–8), your campaign results will only begin to show after 1–2 weeks.

### What to look for in analytics

Navigate to **Analytics → Campaigns**, where you’ll find granular breakdowns of:

* **Open rates**: Can signal subject line quality and deliverability
* **Reply rates**: The key metric for outbound performance
* **Click rates**: Useful if you're including call-to-action links
* **A/B test results**: See which sequence variants are performing best
* **Deal creation**: This is the ultimate success signal. A deal is created when a contact replies positively, requests a demo, or self-signs up.
* **Company-level results**: See which companies are responding most and where your message resonates

You can also break results down by sender mailbox to see if any address is underperforming, or by industry segment or contact title to identify patterns.

### Be patient, iterate strategically

Good outbound takes time. Many teams expect immediate results, but outbound is inherently iterative. After 2–3 weeks, once you have a baseline of performance, you can:

* Pause underperforming sequence variants
* Adjust qualification filters if the audience is weak
* Add stronger CTAs or rewrite subject lines
* Increase volume or add more imports if initial engagement is strong

Outbound should be viewed as an ongoing process — not a one-time blast — and FirstQuadrant is designed to give you the levers to optimize every part of it.

***


# Understanding the true cost of outbound email at scale
Source: https://docs.firstquadrant.ai/playbooks/outbound-costs

At FirstQuadrant, we’re not a traditional outbound email tool — we don’t manage deliverability or infrastructure. But many users still run outbound campaigns through the platform, and there’s a common misunderstanding we often see: the belief that outbound is basically free. It’s not. Once you scale beyond small batches, the costs begin to stack up quickly. Below is a breakdown of the main cost components to help you plan more effectively.

> **Need help with the numbers?**\
> We’ve put together a Google Sheets calculator to help you estimate costs based on your own assumptions. To access it, reach out to our team: \
> \
> [https://docs.google.com/spreadsheets/d/1ij6rc6sgVrjqXRXndgNULbyNaZT-bPVaEs-oMdG2HBU/edit?usp=sharing](https://docs.google.com/spreadsheets/d/1ij6rc6sgVrjqXRXndgNULbyNaZT-bPVaEs-oMdG2HBU/edit?usp=sharing)

***

## Mailboxes

Most people don’t realize that for inbox placement, you can’t send more than \~20 cold emails per day per mailbox. So if your goal is to send 20,000 emails per month, you’ll need around **40 individual mailboxes**.

* These must be real Google or Microsoft Workspace accounts — aliases and SMTP services like SendGrid won’t work.
* Expect to pay roughly **\$7/month per mailbox**.
* Tools like **Zapmail** can help automate and reduce the cost of setting up these mailboxes in bulk.

***

## Domains

You should avoid using more than 3–4 mailboxes per domain to maintain a good sending reputation.

* With 40 mailboxes, you’ll need at least **10+ domains**, each costing around **\$1–2/month**.
* **Never use your primary business domain** for outbound — if it gets flagged or blocked, your main email operations could be affected.

***

## Warming

New mailboxes need to behave like real inboxes before sending cold emails — this includes sending, receiving, and replying to emails over time.

* Some tools like **Instantly** offer unlimited warming for a flat rate (e.g. **\$100/month**).
* Others like **Mailreach** or **Warmup Inbox** charge per mailbox (around **\$20/month per inbox**).
* For 40 mailboxes + backups, warming can easily exceed **\$1,000/month**.

***

## Mailbox rotation

Even warmed inboxes will occasionally get flagged. When this happens, you’ll need to pause and rotate in backups.

* We recommend having **20–30% extra mailboxes warmed** and ready.
* This adds cost, but it’s necessary to ensure uninterrupted sending.

***

## Sequencing tool

You’ll need software to manage sequences, follow-ups, delays, and reply logic.

* Tools like **Apollo** or **Reply** start at around **\$150/month** and scale based on usage.
* *FirstQuadrant can also handle this part if you’re already using the platform — it’s not positioned as a sequencing tool, but it integrates well for teams looking to centralize operations.*

***

## Prospecting and enrichment

* For broad outreach, tools like **Apollo data** (around **\$0.05/contact**) might suffice.
* For more targeted efforts, enrichment tools like **Clay** can cost anywhere between **\$0.10–\$0.80/contact**.
* Don’t forget **email verification** if you're sourcing raw data.

***

## Example breakdown

Let’s say you want to reach out to 5,000 new contacts per month with 3–4 follow-ups. That’s about **20,000 emails/month**.

Here’s a rough cost estimate:

| Component              | Estimated Monthly Cost |
| :--------------------- | :--------------------- |
| Mailboxes (40)         | \$280                  |
| Domains (10+)          | \$10–20                |
| Warming (40–50 boxes)  | \~\$1,000              |
| Sequencing tool        | \~\$150                |
| Prospecting/enrichment | \~\$500+               |
| **Total**              | **\~\$2,000/month**    |

***


# Using FirstQuadrant alongside outbound sales tools like Instantly, Apollo, Outreach, or AI SDRs
Source: https://docs.firstquadrant.ai/playbooks/use-firstquadrant-with-other-outbound-sales-tools

You can use FirstQuadrant in combination with other outbound tools like Instantly, Apollo, Outreach.io, or AI SDR agents. The recommended setup is to use these tools to manage outbound sending, and then let FirstQuadrant take over once a reply is received—automating everything that happens after that initial response.

While FirstQuadrant can also be used end-to-end to run your entire outbound strategy—including prospecting, sequencing, and reply handling—you might already have an outbound tool stack you're happy with. And that's perfectly okay. FirstQuadrant works seamlessly alongside tools like Instantly, Apollo, Outreach, or even AI SDR agents, especially when handling reply automation and deal progression.

## How it works

When you use outbound tools to send emails, FirstQuadrant doesn't interfere. But as soon as a reply comes in—whether it's a positive response, a rejection, an out-of-office notice, or any other type of reply—FirstQuadrant steps in to handle it.

This approach means:

* You don't have to manually manage replies or tag contacts
* Positive replies automatically create deals, assign owners, and trigger the next steps in your sales process
* Even low-value responses like out-of-office emails are filtered and handled appropriately

## Step-by-step setup

### 1. Connect all outbound email accounts

Make sure all email addresses used in your outbound tool are also connected in **Settings → Integrations → [Email accounts](/product-manual/integrations-settings/email-accounts)** within FirstQuadrant. You can connect unlimited email accounts.

### 2. Configure advanced email settings

For each connected outbound email account:

* **Content identifier:**\
  Set a unique identifier (e.g., `Tame-Hedgehog`) to avoid processing emails sent by warming providers. When using large-scale outbound email campaigns, you're likely running your accounts through email warming tools to avoid landing in spam. These warming tools simulate email activity by sending and receiving automated emails. If you don't add a content identifier, FirstQuadrant may mistakenly treat these warming interactions as real leads. By specifying a unique string here, FirstQuadrant can safely ignore those warming emails and only focus on actual replies from prospects. Make sure this identifier matches the one used in your warming provider's settings.
* **Suggested imports:**\
  Enable *"Suggest importing all discovered contacts"*. Since these email accounts are used solely for outbound sales, any incoming reply can safely be assumed to be sales-related. That's why we recommend overriding the workspace default and setting this specifically per account. This ensures FirstQuadrant doesn't miss a contact just because it couldn't confidently classify the email as sales-related. One possible downside is that occasionally, you might get suggested imports for contacts that aren't relevant—like if this email address was accidentally added to a newsletter or a transactional tool. But generally speaking, this mode ensures maximum coverage and the most reliable automation for your outbound flow.
* **Autopilot (optional):**\
  Once the setup is stable and tested, you can turn on *Autopilot*. This lets FirstQuadrant automatically import replies as contacts without asking for confirmation.

> **Info:** You can find these settings by clicking into a specific email address under **[Email accounts](/product-manual/integrations-settings/email-accounts)**, then scrolling to the **Advanced settings** section. Learn more about email account settings in the [respective article](/product-manual/integrations-settings/email-accounts).

### 3. Let FirstQuadrant handle all replies

With this setup, FirstQuadrant will automatically detect replies from your outbound campaigns and take the appropriate next actions:

* Create and assign deals
* Draft or send follow-ups
* Update contact timelines
* Pause ongoing sequences as needed

You no longer need to manually review or act on incoming responses from your outbound tools.

## Alternative configuration

If you prefer more control or want to avoid non-sales suggested imports:

* Keep the workspace default of "suggest importing contacts from sales-related conversations"
* This adds a small safeguard where FirstQuadrant evaluates whether a reply is sales-related before suggesting the contact


# Email data sharing and privacy
Source: https://docs.firstquadrant.ai/policies/email-data-sharing-and-privacy

This article outlines how email data is synced, shared, and managed within FirstQuadrant. It covers syncing rules, visibility settings, and how email data is shared with team members and the AI system. It also explains how users can hide individual emails to maintain privacy while preserving collaboration and AI performance.

At FirstQuadrant, we prioritize your data security and privacy. Below is a detailed explanation of how emails are synced and shared within FirstQuadrant:

## Email syncing rules

* Only emails related to contacts that exist in FirstQuadrant are synced.
* Emails that do not relate to a lead or prospect in FirstQuadrant are not synced.

## Data sharing with team members and AI

* By default, all synced emails are shared with all team members using FirstQuadrant.
* Synced emails are also accessible by FirstQuadrant's AI to enhance recommendations and insights.

## Controlling email visibility

Users have the ability to hide any email from their team and remove it from FirstQuadrant's AI knowledge.

To hide an email:

1. Click on the three dots on the top right of any email.
2. Select "Hide from activity" to prevent the email from being shared.

By following these policies, FirstQuadrant ensures transparency and control over your email data while maximizing sales efficiency.


# Refund policy
Source: https://docs.firstquadrant.ai/policies/fulfillment



At FirstQuadrant, we are committed to ensuring that our customers are fully satisfied with the services and products we provide. We understand that circumstances may arise where you may need to request a refund, and we aim to handle such requests with fairness and transparency. Our refund policy is outlined as follows:

* **Startup or Scaleup Plans**: We want you to feel confident in your decision to use FirstQuadrant. Therefore, if you are not satisfied with our services for any reason, we offer a refund within 7 days of the initial subscription purchase. This refund policy is specifically for first-time customers. Please note that if you have renewed your subscription or previously canceled and then re-subscribed, you will not be eligible for a refund under this policy.

* **Enterprise Plan**: Our Enterprise Plan is tailored to meet the unique needs of each client, and due to the customized nature of these solutions, we do not offer refunds once the collaboration has begun. However, we value the quality of our work, and if the delivered solution is found to be materially defective or significantly deviates from the agreed-upon specifications, we will make every effort to rectify the issue. In the event that a resolution cannot be reached, a partial refund may be considered. Please note that the decision to issue a refund is at the sole discretion of FirstQuadrant and will be evaluated on a case-by-case basis.

* **Refund Process**: To request a refund, please contact our support team at [enquiry@firstquadrant.ai](mailto:enquiry@firstquadrant.ai). In your request, include your subscription details, the reason for your refund request, and any supporting documentation. Our team will review your request and, if approved, will process the refund within 10 business days. The refund will be credited to the original payment method used during the purchase.

## Delivery policy

FirstQuadrant delivers all services and products electronically, ensuring that you have immediate access to the tools and resources you need to succeed. Our delivery policy is as follows:

* **Software Access and Subscriptions**: Upon successful payment, you will receive immediate access to the FirstQuadrant platform. This access is granted through your account dashboard, where you can utilize the features and tools associated with your subscription level. An email confirmation will also be sent to you with the details of your subscription, including the start date, duration, and any additional resources that may be included.

* **Digital Product Delivery**: For any additional digital products or services that are part of your subscription, delivery will occur through the FirstQuadrant platform or via direct email. You will be notified immediately upon delivery, and access will be granted without delay.

## Return policy

At FirstQuadrant, we deal exclusively in digital products and services, which means that traditional return methods are not applicable. However, we are committed to ensuring the functionality and quality of all digital products delivered through our platform. Our return policy is detailed below:

* **Non-Tangible Products**: Once access to our platform, digital tools, or services is granted, all sales are considered final. This policy covers all software, subscriptions, and digital services provided by FirstQuadrant. We recommend thoroughly reviewing your purchase details and subscription plan before completing your transaction.

* **Defective Digital Products**: In the rare event that a digital product is delivered in a defective state, please contact our support team within 7 days of delivery. Our team will work with you to provide technical support and resolve any issues you are experiencing. If a solution cannot be provided, we will issue a replacement or, in exceptional cases, consider alternative remedies.

## Cancellation policy

We recognize that business needs can change over time, and we strive to offer flexible cancellation options to accommodate these changes. Our cancellation policy is as follows:

* **Subscription Services**: You may cancel your subscription at any time through your account settings on the FirstQuadrant platform. Upon cancellation, your subscription will remain active until the end of the current billing cycle, after which it will not renew, and no further charges will be made. Please note that we do not offer refunds or credits for any unused time remaining in your billing period, so we recommend scheduling your cancellation accordingly.

* **Enterprise Plan Cancellation**: Due to the customized nature of our Enterprise Plan, cancellation terms are agreed upon during the initial contract phase. If you need to terminate an Enterprise Plan, please refer to your contract for specific cancellation terms and conditions. Early termination fees may apply, depending on the terms outlined in your agreement.

### Contact Information

For any questions, assistance, or to initiate a request under any of our policies, please do not hesitate to contact our dedicated support team. We are here to help and ensure your experience with FirstQuadrant is positive.

* **Address**: 1209 N. Orange Street, Wilmington, DE 19801, United States
* **Phone**: +1 (440) 73 PABIO
* **Email**: [enquiry@firstquadrant.ai](mailto:enquiry@firstquadrant.ai)

We are committed to providing clear, fair, and customer-friendly policies that enhance your experience with FirstQuadrant. Your satisfaction is our priority, and we welcome any feedback that can help us improve our services.


# Legal notice
Source: https://docs.firstquadrant.ai/policies/legal-notice



## Company address

**FirstQuadrant Inc.** (previously Pabio Inc.)\
149 New Montgomery St. 4th Floor\
San Francisco, California 94105‌\
United States

## Directors

1. Carlo Badini
2. Anand Chowdhary

## Contact

[enquiry@firstquadrant.ai](mailto:enquiry@firstquadrant.ai)\
+1 (440) 737-2246


# Privacy policy
Source: https://docs.firstquadrant.ai/policies/privacy



*Privacy Policy effective January 12, 2023.*

## Introduction

This Privacy Policy describes how FirstQuadrant Inc. ("FirstQuadrant", "we", "us", or "our") collects, uses, and shares your personal information when you use our services, website, or applications (collectively, the "Service").

## Information we collect

We collect several types of information from and about users of our Service, including:

* Personal identifiers (such as name, email address, phone number)
* Professional information (such as company name, job title)
* Usage data (such as how you interact with our Service)
* Device information (such as IP address, browser type, operating system)

## How we use your information

We use the information we collect to:

* Provide, maintain, and improve our Service
* Process transactions and send related information
* Respond to your comments, questions, and requests
* Send you technical notices, updates, and administrative messages
* Communicate with you about products, services, offers, and events
* Monitor and analyze trends, usage, and activities in connection with our Service
* Detect, prevent, and address technical issues

## Data sharing

We may share your personal information with:

* Service providers who perform services on our behalf
* Professional advisors, such as lawyers, auditors, and insurers
* Business partners with whom we jointly offer products or services
* Third parties in connection with a business transaction such as a merger or acquisition
* Foundational LLM model providers

## Data protection

We have taken steps to protect any personal information we process. However, please keep in mind that the internet is not completely secure. Although we are committed to protecting your personal information, it is your responsibility to ensure that you only access our services in a secure environment.

## Rights

### European Economic Area

If you live in the European Economic Area, you have certain rights under data protection laws. This includes the right to ask for access to your personal information, to request that it be changed or deleted, to limit how it is used, and to get a copy of it. You can also object to how your personal information is processed. To make such a request, please use the contact details provided. If we have your consent to process your personal information, you can withdraw your consent at any time. If you think your personal information is being used illegally, you have the right to complain to your local data protection authority. You can find their contact details at [ec.europa.eu](http://ec.europa.eu/justice/data-protection/bodies/authorities/index_en.htm).

### California Civil Code Section 1798.83

If you are a resident of California, you have the right to request information from us once a year free of charge. This information includes what kind of personal information we shared with third parties for marketing purposes, and the names and addresses of those third parties. If you would like to make this request, please contact us using the information provided.

If you are under 18 years old, reside in California, and have a registered account with us, you have the right to request that we remove any data you posted publicly on our Services. To do this, please contact us with your email address associated with your account and a statement that you live in California. We will not display the data publicly, but it may not be completely or thoroughly deleted from our systems.

### CCPA Privacy Rights (California residents)

Under the California Consumer Privacy Act (CCPA), California residents have specific rights regarding their personal information:

* Right to know about personal information collected, disclosed, or sold
* Right to request deletion of personal information
* Right to opt-out of the sale of personal information
* Right to non-discrimination for exercising CCPA rights

To exercise these rights, please contact us using the information provided below.

### Minors

We do not ask for or market to children under 18. If you are 18 or the parent/guardian of a minor, you can allow them to use the services. If we find out that we have collected data from someone under 18, we will delete the information and deactivate their account. If you are aware of any children under 18 using our services, please contact us.

## Data breaches

If someone gets unauthorized access to, collects, uses, discloses, or disposes of your personal information, it is called a privacy breach. We will let you know if we think you may be at risk of harm. This could be serious financial harm or harm to your physical or mental health. If we find out about a security breach that could let someone access, use, or see your personal information, we will investigate and inform you at the earliest possible date.

## Cookies and tracking technologies

We use cookies and similar tracking technologies to track activity on our Service and hold certain information. Cookies are files with a small amount of data which may include an anonymous unique identifier. You can instruct your browser to refuse all cookies or to indicate when a cookie is being sent.

## Do Not Track headers

Many web browsers, mobile devices, and mobile applications have a feature called Do-Not-Track ("DNT"). If you activate this feature, it sends a signal that you do not want your online browsing activities monitored and collected. No technology has been finalized yet that recognizes and follows DNT signals. Because of this, we do not currently respond to DNT signals. If a standard for online tracking is created in the future, we will let you know in an updated version of this privacy policy.

## International data transfers

Your information may be transferred to — and maintained on — computers located outside of your state, province, country, or other governmental jurisdiction where the data protection laws may differ from those of your jurisdiction. If you are located outside the United States and choose to provide information to us, please note that we transfer the data to the United States and process it there.

## Partners

We work with a number of partners to provide the Service. These partners may have access to your personal information, and you accept their privacy policies by using FirstQuadrant. Please contact us if you would like to know more about our partners and the data we share with them.

## Data retention

We will retain your personal information only for as long as is necessary for the purposes set out in this Privacy Policy. We will retain and use your information to the extent necessary to comply with our legal obligations, resolve disputes, and enforce our policies.

## Updates

We may update this privacy policy from time to time. We encourage you to review this privacy policy frequently to be informed of how we are protecting your information.

## Questions

If you have questions or comments about this policy, you may contact FirstQuadrant Inc.'s Data Protection Officer (DPO):

* **Address:** 1209 N. Orange Street, Wilmington, DE 19801, United States
* **Phone:** +1 (440) 73 PABIO
* **Email:** [dpo@pabio.com](mailto:dpo@pabio.com)


# Privacy and data practices
Source: https://docs.firstquadrant.ai/policies/privacy-practices

This article outlines FirstQuadrant’s data privacy and security practices, including encryption, data retention, subprocessors, breach response, and data residency.

## Encryption at rest and in transit

All data is encrypted both in transit and at rest:

* **In transit**: Data is encrypted using TLS 1.2 or higher. All connections to our backend (hosted on Vercel) are secured via HTTPS.
* **At rest**: We use Supabase, hosted on AWS (us-west-1), which encrypts data at rest using AES-256 encryption.

## Subprocessors

We rely on third-party service providers (subprocessors) to help deliver FirstQuadrant functionality. These providers may have access to limited customer data in accordance with their role.

## Certifications

We do not currently hold any certifications such as SOC 2 or ISO 27001. However, we follow modern security best practices and are actively evaluating certification options.

## Incident response and breach notification

We continuously monitor our systems for suspicious activity and security breaches. If a data breach is confirmed, we will notify affected customers without undue delay — and always within **72 hours**, in accordance with GDPR requirements.

## Data retention and deletion

### What happens after account closure?

1. **One week after an account is closed**, we initiate a deletion process.
2. A **soft delete** is applied in our primary database (Supabase). This hides the data from the application and internal workflows, but it technically remains available for recovery if needed (e.g. accidental closure).
3. **Encrypted backups**, which may contain soft-deleted data, are retained for **7 days**. After this window, all backup data is **permanently deleted**.
4. We are working on implementing **automatic permanent deletion** of soft-deleted data in our primary database after the 7-day backup window. Until then, full manual deletion is available on request.

If you’d like your data fully and permanently deleted sooner, please contact our support team.

## Data residency and EU compliance

We understand the importance of complying with UK/EU data residency requirements.

* Our **core infrastructure** is hosted in the **US** but we configure our systems to limit data access in line with GDPR.
* We have not set up a separate EU-region application and **do not currently offer EU-only routing**.

If your compliance needs require UK/EU-only routing for Nylas, please reach out to discuss alternatives or custom options.

***

If you have any further privacy or data questions, please contact our support team or your customer success manager.


# Security policy
Source: https://docs.firstquadrant.ai/policies/security



## Introduction

This Security Policy outlines FirstQuadrant Inc.'s ("FirstQuadrant", "we", "us", or "our") approach to security and how we handle security-related reports and vulnerabilities.

## Our commitment to security

We take security seriously and are committed to protecting our users' data and maintaining the security of our services. We implement industry-standard security measures and regularly review and update our security practices.

## Security reporting

We do not currently operate a bug bounty program, but we welcome responsible disclosure of security vulnerabilities and can evaluate on a case by case basis. If you discover a security vulnerability in our services, we encourage you to report it to us directly. We welcome reports of high-impact issues, including (but not limited to):

* Insecure Direct Object References (IDOR)
* Cross-Site Scripting (XSS)
* Server-Side Request Forgery (SSRF)
* Remote Code Execution (RCE)
* SQL Injection or command injection
* Broken access controls or authentication logic
* Sensitive data exposure (e.g., secrets, tokens, credentials)
* Misconfigured OAuth or JWT implementations
* Business logic flaws that could lead to abuse or fraud

These issues must be demonstrated with clear, reproducible steps showing real impact.

### Out-of-scope submissions

To help us prioritize effectively, we do not accept or reward submissions for:

* Missing security headers (e.g., X-Frame-Options, X-XSS-Protection)
* Open redirects unless exploitable in sensitive flows (e.g., OAuth)
* Verbose error messages without sensitive data
* Dangling CNAMEs with no production traffic
* SPF/DKIM/DMARC misconfigurations
* Exposed server version banners or stack info
* Access to robots.txt, .git, or .env without secrets
* HTTP methods like OPTIONS or TRACE unless abused
* Clickjacking reports on non-sensitive pages or autocomplete fields

If you believe such issues could be chained into a real exploit, please include a clear proof of concept.

### How to report security issues

If you find a security vulnerability, please:

1. Email your findings to [security@firstquadrant.ai](mailto:security@firstquadrant.ai)
2. Provide detailed information about the vulnerability
3. Include steps to reproduce the issue
4. Share any relevant proof-of-concept code or screenshots
5. Do not publicly disclose the vulnerability until we have had a chance to address it

### What to expect

Upon receiving your report, we will:

1. Acknowledge receipt of your report within 48 hours
2. Investigate the reported vulnerability
3. Keep you informed of our progress
4. Work to resolve the issue as quickly as possible
5. Credit you in our security acknowledgments (unless you prefer to remain anonymous)

### Guidelines for responsible disclosure

When reporting security issues, please:

* Do not attempt to access or modify user data
* Do not attempt to disrupt our services
* Do not share or publish the vulnerability until we have addressed it
* Do not attempt to exploit the vulnerability beyond what is necessary to demonstrate it
* Provide clear, detailed information about the vulnerability

## Security acknowledgments

We maintain a list of security researchers who have responsibly disclosed vulnerabilities to us. If you would like to be credited for your report, please let us know when submitting your findings.

## Updates

We may update this security policy from time to time. We encourage you to review this policy periodically to stay informed about our security practices and reporting procedures.

## Questions

If you have any questions about this security policy or our security practices, please contact us at [security@firstquadrant.ai](mailto:security@firstquadrant.ai).


# Terms of Service
Source: https://docs.firstquadrant.ai/policies/terms



*Beta Terms of Service effective January 12, 2023.*

## Service description

The Service provides sales assistance, including but not limited to text generation and customer engagement.

## Suspension of service

We reserve the right to suspend or terminate your access to the Service at any time and for any reason. The FirstQuadrant Beta Terms will automatically terminate upon the release of a generally available version of the FirstQuadrant applications. You acknowledge FirstQuadrant is under no obligation to make the Service generally available and may never do so. Further, should the Service become generally available, you acknowledge that continued access and use of the Service may be subject to your agreement to pay additional fees. FirstQuadrant reserves the right to modify or terminate the Service or the FirstQuadrant Beta Terms, and to limit or deny access to the Service, at any time, in our sole discretion, for any reason, with or without notice and without liability to you.

You may discontinue your use of the Service at any time by uninstalling the applicable application(s) and optionally sending an email to [support@firstquadrant.ai](mailto:support@firstquadrant.ai) requesting that your FirstQuadrant account be deleted.

## Intellectual property rights

You agree that, we own all legal rights, title and interest in and to the Service, including all intellectual property rights, and except for the license provided herein, no other rights or permissions to the Service is granted. All generated text by the Service is also owned by us.

Nothing herein gives you a right to use any of our trade names, trademarks, service marks, logos, domain names, and other distinctive brand features. Except to the extent permitted by law, you may not modify, distribute, prepare derivative works of, reverse engineer, reverse assemble, disassemble, decompile or otherwise attempt to decipher any code in connection with the Service and/or any other aspect of FirstQuadrant technology, except as permitted by us.

By signing up for our services (including free trials, paid plans, or joining the waitlist), you grant us a non-exclusive, royalty-free, worldwide license to use, reproduce, publish, and display your logo and trademarks in connection with your use of our services. This includes, but is not limited to, use on our website, in marketing materials, presentations, and advertisements to identify you as a customer. You represent and warrant that you have the authority to grant this license on behalf of your organization. This license remains in effect unless and until you revoke it by contacting us on the email address listed at the bottom of this document. Upon revocation, we will make reasonable efforts to remove your brand within 30 days.

## Governing law

This agreement will be governed by and construed in accordance with the laws of the country, without regard to its conflict of laws provisions.

## Limits on liability

In no event shall FirstQuadrant or its affiliates be liable for any indirect, special, consequential or incidental loss, exemplary or other damages related to these FirstQuadrant Beta Terms whether direct or indirect, however caused and based on any theory of liability, and whether or not for breach of contract, tort (including negligence), violation of statute, or otherwise, and whether or not FirstQuadrant has been advised of the possibility of such damages. To the extent permitted by applicable law, FirstQuadrant's maximum liability hereunder is limited to \$10.

Some jurisdictions do not allow limitation or exclusion of liability for incidental or consequential damages, so some of the above limitations may not apply to you.

You agree to comply with the CAN-SPAM Act of 2003, the European Union's ePrivacy Directive, and all other applicable laws and regulations. You agree to not use the Service to send email that is misleading, deceptive, or fraudulent, or that violates the rights of others. If the laws of your country or jurisdiction require you to obtain consent from your recipients before sending them commercial email, you agree to do so before using the Service to send such email. You agree to comply with all applicable laws and regulations in connection with your use of the Service, and that the Service is not responsible for your compliance with such laws and regulations. You agree to indemnify and hold harmless the Service from any and all claims, damages, liabilities, costs, and expenses (including reasonable attorneys' fees) arising from or related to your use of the Service.

## Modifications to terms

FirstQuadrant reserves the right to modify these Terms of Service at any time. We will notify you of any changes by posting the new Terms of Service on our website. Changes will be effective immediately upon posting. Your continued use of the Service after any such changes constitutes your acceptance of the new Terms of Service.

## Severability

If any provision of these Terms of Service is found to be unenforceable or invalid, that provision will be limited or eliminated to the minimum extent necessary so that these Terms of Service will otherwise remain in full force and effect and enforceable.

## Warranty disclaimer

You hereby acknowledge and agree that the Service provided by FirstQuadrant on an "as is" basis and as available, and your access to and/or use of the Service are at your sole risk. To the extent permitted by applicable law, FirstQuadrant expressly disclaims all and you receive no warranties and conditions of any kind, whether express or implied, including, but not limited to, those of merchantability, satisfactory quality, title, fitness for a particular purpose and non-infringement. FirstQuadrant makes no warranty that any of the services will meet your requirements and/or that the services will be uninterrupted, timely, error-free or secure. You acknowledge and agree that the Service is not in scope for an SOC 2 type IIT and other independent security audits and security certifications. Some jurisdictions do not allow the exclusion of certain warranties and conditions, so some of the above exclusions may not apply to you.

You may send requests for technical support by emailing [support@firstquadrant.ai](mailto:support@firstquadrant.ai).


# YC-backed AI sales platform FirstQuadrant acquires Flike
Source: https://docs.firstquadrant.ai/press-releases/2024-06-14-firstquadrant-acquires-flike



<img src="https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=92dc91e0c78e258421a68514da5b3a6c" alt="Icons of FirstQuadrant and Flike" data-og-width="1200" width="1200" data-og-height="826" height="826" data-path="images/press-releases/flike.jpeg" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?w=280&fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=b3b5935ffb79192324f799d1dc16355f 280w, https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?w=560&fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=e050bec75766ada37948f5984ac75b10 560w, https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?w=840&fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=cef1990ec73f4f49932bb378172c40aa 840w, https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?w=1100&fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=f4d92657c5712f75318736421f0845c0 1100w, https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?w=1650&fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=1ff232714a3b56c7014f8cf79149c2a3 1650w, https://mintcdn.com/firstquadrant/6fsIvlI40fB8hehD/images/press-releases/flike.jpeg?w=2500&fit=max&auto=format&n=6fsIvlI40fB8hehD&q=85&s=e2cf40708c2183bb1b81f1e3730d5109 2500w" />

**San Francisco, CA** — FirstQuadrant, a leading AI sales platform, is excited to announce its acquisition of [Flike](https://flike.app). This acquisition supports FirstQuadrant's mission to empower tech companies to achieve sustained, exponential growth through cutting-edge AI sales automation.

## Strategic acquisition for enhanced growth

This strategic acquisition aligns with FirstQuadrant's commitment to fostering progress across the tech industry by leveraging cutting-edge AI. Both FirstQuadrant and Flike are backed by Y Combinator and focus heavily on large language models to power their applications.

"Our goal is to drive transformative growth across the tech industry," said Carlo Badini, co-founder and CEO of FirstQuadrant. "The acquisition of Flike is an important step towards expanding our capabilities and supporting our clients in reaching their sales targets."

Anand Chowdhary, co-founder and CTO of FirstQuadrant, added, "We are excited about the potential this acquisition brings to enhance our offerings and deliver even more value to our customers."

Flike has established itself as a trusted partner for ambitious sales teams, with notable customers such as Brex and Brightspot. This asset deal will allow both companies to focus on their core strengths and continue delivering exceptional customer value.

## About FirstQuadrant

FirstQuadrant is dedicated to accelerating growth in the tech industry through its scalable AI sales platform. By providing tools for inbound, outbound, and nurturing sales, FirstQuadrant helps B2B businesses to fully automate and enhance their sales processes.

## About Flike

Flike is renowned for its AI-driven sales co-pilot, which helps sales teams generate personalized messages and improve engagement rates. With a strong customer base including Brex and Brightspot, Flike supports sales teams in achieving their goals.


# FirstQuadrant has been sunset
Source: https://docs.firstquadrant.ai/press-releases/2025-11-01-firstquadrant-has-been-sunset



**San Francisco, CA — November 1, 2025 — After an incredible journey, we are announcing that FirstQuadrant has been sunsetted.** We are deeply grateful for the trust and support of our community, customers, investors, and partners throughout the years. Together, we built an innovative AI sales platform that helped companies scale across industries and transform how they approach the sales pipeline.

We have completed a confidential agreement with a leading AI technology company that recognized long-term strategic value in components of the FirstQuadrant platform and data infrastructure.

***

Since our founding in 2022, FirstQuadrant has been at the forefront of applying AI to sales operations, building one of the first AI SDR agents, helping teams personalize their outreach at scale while maintaining authenticity and relevance. Our platform processed an immense volume of interactions, helped generate countless qualified leads, and supported sales teams in achieving their goals more efficiently than ever before.

What began as a vision to transform outbound motions evolved into a comprehensive sales automation platform trusted by companies ranging from fast-growing startups to established enterprises. Along the way, we had the privilege of working with an incredible community of users who pushed us to innovate, provided invaluable feedback, and inspired us with their creative use of our platform.

As we have completed an agreement with a leading AI technology company, the FirstQuadrant platform will be sunsetted. Thank you for believing in our vision and for being early adopters of AI-powered sales automation. Your feedback, feature requests, and success stories have been the driving force behind every improvement we made.

Please download any needed data from your workspaces and request exports in the Slack Connect channel. Your subscriptions have automatically been canceled and no further charges will occur, and access to any connected integrations will be revoked. We are committed to ensuring a smooth transition and will continue to provide support during this period.

While this chapter is closing, we are proud of what we built together and the impact FirstQuadrant had on the sales technology landscape..

Thank you for being a part of our story.

With gratitude,

[Carlo Badini](https://carlobadini.com) and [Anand Chowdhary](https://anandchowdhary.com)


# Actions
Source: https://docs.firstquadrant.ai/product-manual/actions

This guide explains how to use the Actions List in FirstQuadrant, your central inbox for AI-generated to-do items. It covers how to navigate, filter, sort, and manage action items, along with best practices for keeping your sales execution pipeline clear and responsive.

## Overview

The **actions tab** is the operational heart of FirstQuadrant. It serves as your AI-curated inbox of to-do items, dynamically generated based on ongoing sales conversations and activity. Every item on this list reflects a step the AI believes should be taken next. Your goal: process this list until it’s empty, just like clearing out your inbox at the end of the day.

***

## Structure of the actions list

The actions list is divided into two key sections:

### Main action list

Each row in the list contains by default:

* **Contact**: The person associated with the task.
* **Action**: A description of what the AI recommends doing next (e.g., send follow-up email, reschedule demo)
* **Tags**: Indicators that give quick insight into the context of the last activity (e.g., "[Nurturing](/product-manual/nurturing)", "Follow-ups", "Positive")
* **Date**: When the task was created
* **Assignee**: The team member responsible for completing the action

### Context panel (right side)

When you click on a row, the [context panel](/product-manual/contact-view/context-panel) shows detailed context for that action:

* **Deal details**: Status, stage, pipeline, and value
* **Contact details**: Name, status, time zone, email, LinkedIn, etc.
* **Company details**: Name, description, website, funding info, and historical funding round data

***

## Managing and filtering actions

### Filter options

Click on **Filters** above the action list to narrow down results. Filter by:

* Team member
* Contact attributes (name, nickname, website, location, time zone, etc.)
* Deal info (stage, value, company attributes)
* Tags such as "[part of a campaign](/product-manual/campaigns/campaign-overview)", "unsubscribed", or "archived"

### Display settings

Click on **Display** (top right) to:

* Choose which data columns are shown in the action list
* Sort actions by creation date or other fields (e.g., contact name, last received, company, action)

### Search

Use the **search bar** to quickly locate specific action items by keyword.

***

## Understanding action statuses

Each action item can be in one of four states:

### To do

Items that require immediate attention. These are your daily priorities and appear by default in the actions list.

### Later

Tasks scheduled for the future or snoozed items. These do not require action now.

### Running

Indicates that FirstQuadrant’s AI is currently working on these items. You'll see a "Running AI reasoning" label at the top right when active.

### Completed

Tasks that have been approved or otherwise resolved.

***

## Taking action on your list

You can handle to-do items individually or in bulk:

### Individual management

Click any row to view context and either approve or modify the recommendation. This allows for individual approval of each action item.

### Bulk actions

Hover over the left side of the list to select multiple items. At the bottom of the screen, you can then:

* **Approve** all selected actions
* **Snooze** them (move to Later)
* **Delete** them
* **Export** the selection

***

## Best practices

* **Empty your to-do list daily**: Treat it like your inbox—if it's full, decisions are pending
* **Review context before approving**: Always check the context panel when unsure
* **Use filters to declutter**: Especially useful if your list includes items not immediately relevant (e.g., long-term nurtures)
* **Bulk-approve repetitive actions**: This speeds up execution for high-volume campaigns or follow-ups

***

## Summary

The actions list is your day-to-day execution layer in FirstQuadrant. The AI does the heavy lifting by recommending next steps. Your job is simply to approve, modify, or decline—and to ensure nothing important gets missed. When used properly, this system ensures you and your team always act on the most meaningful sales opportunities with precision and efficiency.


# Analytics
Source: https://docs.firstquadrant.ai/product-manual/analytics

This article explains the Analytics Dashboard in FirstQuadrant, covering both the Pipeline and Campaigns dashboards. It outlines key performance metrics, funnel stages, breakdowns by owner and company, and how to interpret A/B testing results. The guide helps users monitor sales performance and campaign effectiveness across pipelines and outreach sequences.

The analytics section in FirstQuadrant is divided into two dashboards: the **Pipeline Dashboard** and the **Campaigns Dashboard**. You can switch between both views using the toggle at the top of the screen.

## Pipeline dashboard

The Pipeline Dashboard is the default view. It shows all major KPIs across your selected pipeline.

### Key metrics

* **Deals created**: Total number of deals the AI has created across this pipeline
* **Deals won**: Number of deals marked as won
* **Conversion rate**: Calculated as (Deals won / Deals created) across the funnel stages
* **Won value**: Total value of deals marked as won
* **Weighted value**: The expected deal value across all open opportunities, weighted by probability
* **Total value**: The sum of all deal values, regardless of probability or deal stage

### Pipeline funnel

A visual funnel displays deal progression through the following stages:

* Contacted
* Demo call
* Negotiation
* Won

This helps identify conversion rates and drop-offs at each step.

### Breakdown sections

* **Weighted value per owner**: Expected pipeline value by each sales owner
* **Won value per owner**: Total value of deals marked as won, by owner
* **Won per owner**: Count of won deals per person
* **Weighted value per company**: Expected value by company
* **Won per company**: Companies for which deals were won and the respective values

You can switch between different pipelines using the dropdown in the top navigation bar to compare across sales motions, product lines, or geographies.

## Campaigns dashboard

The Campaigns Dashboard provides visibility into outbound campaign performance, including email activity and deal outcomes.

### Campaign-level metrics

* **Sequences**: Number of triggered email sequences
* **Emails sent**: Total emails sent across all sequences
* **Deal creation rate**: Percentage of sequences that led to a deal
* **Deal win rate**: Percentage of created deals marked as won
* **Open rate**: Average open rate across all sent emails
* **Reply rate**: Percentage of emails that received replies
* **Click rate**: Percentage of emails that led to link clicks

### A/B testing

If you are running [A/B tests on sequences](/product-manual/campaigns/create-sequence#creating-ab-test-variants), performance is shown for each variant:

* Sent
* Opened
* Replied
* Clicked
* Deals created
* Deals won

These results help you evaluate which sequence performs best.

### Additional breakdowns

* **Sequences per company**: Which companies received the most outreach
* **Replies per company**: Which companies responded and how often
* **Deals created per company**: Tracks active opportunities created from sequences
* **Deals won per company**: Companies that resulted in closed-won deals

## Notes

* Data is updated in near real-time. A timestamp at the top-right of the screen shows the last refresh time.


# Autopilot
Source: https://docs.firstquadrant.ai/product-manual/autopilot

The autopilot feature in FirstQuadrant enables automated execution of planned actions without manual approval. When turned on, autopilot allows FirstQuadrant to immediately send emails, respond to incoming messages, execute fine-tuned rules, apply nurturing logic, and import suggested contacts—streamlining workflows and reducing manual effort. It can be toggled on or off in four key areas: campaigns, fine-tuning rules, nurturing, and AI suggestions. By default, autopilot is off to ensure safety and control, and it only activates autonomously when all applicable rules agree. Use it to scale efficiently while maintaining oversight.

The **autopilot** feature in FirstQuadrant enables users to fully automate key parts of the sales process. While it appears in multiple places across the platform, its function is always consistent: when **autopilot is off**, FirstQuadrant plans actions but requires human approval to execute them. When **autopilot is on**, FirstQuadrant proceeds to **automatically execute** actions without manual confirmation.

Autopilot is **off by default** across the system to prevent unintended communication or actions.

## When autopilot is off

FirstQuadrant will:

* **Generate and draft** the next steps (like email replies, follow-ups, imports)
* Add these steps to the **[Actions list](/product-manual/actions)** for manual review and approval
* Not execute any steps automatically

## When autopilot is on

* FirstQuadrant **executes next steps immediately** after planning them—no human-in-the-loop required
* This applies only to the specific context where autopilot is enabled
* Use with caution: enabling autopilot should reflect your confidence in the system's recommendations and safeguards

> **Note**: Use autopilot thoughtfully. While it greatly increases efficiency, it’s important to ensure your logic, sequences, and rules are set up correctly to avoid undesired communications or actions.

## Where autopilot is used

Autopilot can currently be toggled in four main areas of the product:

### Campaigns

Autopilot can be activated when setting up a [campaign sequence](/product-manual/campaigns/campaign-overview).

* **Effect**: Email sequences are sent without requiring manual approval of each message
* **Additional campaign-specific setting**: You can choose to **turn autopilot off for contacts with an existing conversation history**. This ensures FirstQuadrant doesn't reach out to people you've already been in touch with unless explicitly approved

This allows you to:

* Fully automate outreach to new leads
* Maintain control over ongoing conversations

### Fine-tuning rules (Email and Note)

Autopilot can be enabled for both email and note-based [fine-tuning rules](/product-manual/fine-tuning/fine-tuning-overview).

* When enabled, FirstQuadrant will **automatically respond and take the next best steps** based on the rule's instructions
* If **multiple fine-tuning rules are triggered simultaneously**, autopilot will only activate if **all triggered rules** have autopilot turned on
* If at least one rule has autopilot off, the response will be held for **manual approval** and appear in the Actions list

**Examples:**

* Automatically confirming a meeting reschedule
* Sending a reminder if a lead postpones the conversation

### Nurturing

[Nurturing rules](/product-manual/nurturing), when combined with autopilot, allow FirstQuadrant to take action on long-term lead engagement tasks.

* The same rule as above applies: all applicable rules must have autopilot on for it to execute without human review

### Suggested imports

Autopilot can also be used for [suggested imports](/product-manual/workspace-settings/suggested-imports).

* When **suggested imports** are enabled, FirstQuadrant scans your email and calendar to suggest contacts worth importing
* If autopilot is off, these contacts appear as **manual suggested imports**
* If autopilot is on, FirstQuadrant will **automatically import** sales-relevant contacts into your workspace without manual review


# AI credits pricing 
Source: https://docs.firstquadrant.ai/product-manual/billing-settings/ai-credits-pricing

FirstQuadrant uses a single, flexible AI credit system where credits are spent based on usage—like property enrichment, actions, or campaigns. Credits scale with activity, not seats, and plans offer predictable monthly or flexible annual options with rollover. ScaleUp users benefit from unlimited seats.

FirstQuadrant operates on a flexible credits-based pricing system. Credits are used to power various AI-driven features and automation throughout the platform. The way credits are allocated and consumed depends on your billing plan.

***

## Why FirstQuadrant uses a credit-based pricing model

Credit-based pricing lets FirstQuadrant align cost with real usage and outcomes, not headcount.

* **No per-seat pricing**: We want everyone on your team using the platform. The more inboxes connected, the better the AI performs.
* **Aligned incentives**: You pay for outcomes, not access. FirstQuadrant only benefits when you use the product to drive real results.
* **Flexible structure**: Monthly plans are predictable; annual plans allow unused credits to roll over.

***

## Monthly vs. annual plans

### Monthly plans

* You receive a fixed number of credits each month.
* **Unused credits do not roll over**—they expire at the end of each billing cycle.

### Annual plans

* You receive a fixed number of credits each month, just like with monthly plans.
* **Unused credits roll over**—they accumulate month-to-month for the duration of your subscription.

> **Info** If you're on the Scaleup plan, you get **unlimited seats**—so your entire team can use FirstQuadrant without additional per-user costs.

***

## Unlimited users with the ScaleUp plan

With the **ScaleUp plan**, you can add **unlimited users** to your FirstQuadrant workspace at **no additional cost**. There are no per-seat or per-user fees—inviting more team members is completely free. This means you can bring your entire team onboard, collaborate seamlessly, and maximize the value of FirstQuadrant without worrying about extra charges for each user you add.

* **Unlimited seats**: Add as many users as you need—no restrictions.
* **No extra cost**: You only pay for your plan and AI credit usage, not for the number of users.
* **Team collaboration**: Empower everyone on your team to use FirstQuadrant’s features and AI-driven automation.

***

## AI credits breakdown

FirstQuadrant uses a **single type of AI credit**, but credits are **spent in different ways** depending on the specific AI-powered task being performed. Below is a breakdown of how credits are consumed:

Credits are consumed whenever you use AI-powered features like property enrichment, campaign generation, or triggering actions. Here's a detailed breakdown:

### Qualification credits

* **1 credit per 10 records qualified using Perplexity search**\
  AI is used to fetch external data like “Is this a remote-first company?”
* **1 credit per 100 records qualified using internal data**\
  AI qualifies records based on provided data (e.g., detecting if a company is B2B based on a note added manually).

### Enrichment credits

* **1 credit per 10 records enriched using Perplexity search**\
  External data is fetched using Perplexity, such as funding round information.
* **1 credit per 100 records enriched using internal data**\
  FirstQuadrant AI enhances data using proprietary datasets.

### Action credits

* **3 credits per action processed**\
  These credits are used when FirstQuadrant processes input data (e.g., emails, calendars, updates, notes) and decides the next best sales action.

### Campaign credits

* **1 credit per email sequence generated**\
  FirstQuadrant uses AI to generate personalized outbound campaigns, including full multi-step email sequences.

***


# Credit usage
Source: https://docs.firstquadrant.ai/product-manual/billing-settings/credit-usage

Learn how to track, manage, and interpret your AI credit consumption in FirstQuadrant, including credit types, usage logs, and what happens when you run low.

## Accessing credit usage

You can always see your current credit usage in the left-hand site navigation. This shows how many AI credits you’ve used in your billing period and how many remain.

Clicking this indicator takes you directly to the **Billing → Usage** section of the settings.

***

## Usage breakdown

At the top of the usage page, you’ll find a usage bar visualizing your AI credit consumption for the current billing period. This chart is broken down by the different types of credit use:

* **Actions** – Generated tasks like follow-ups or email sequences
* **Property enrichment (internal data)** – Filling in custom properties using internal signals
* **Property enrichment (Perplexity)** – Enriching properties via Perplexity data
* **Qualifying answer (internal data)** – AI-generated qualification based on FirstQuadrant internal data
* **Qualifying answer (Perplexity)** – Qualification using Perplexity results
* **Sequences** – Multi-step email sequence generations

> **Info**: To help you avoid unnecessary credit spending, FirstQuadrant will automatically archive a contact if it processes multiple incoming emails or events for that contact without you approving any of the suggested actions. This prevents credits from being consumed without user engagement. You can manually reactivate the contact at any time to resume AI processing.

***

## Credit usage log

Below the chart, you'll see a log of all credit-consuming events. Each row includes:

* **Timestamp** of usage
* **Number of credits used**
* **Type of activity** (e.g., Action, Enrichment)
* **Associated record** (e.g., Contact or Company)
* **Details** on what the credit was used for

You can click the three-dot menu on the right of each row to quickly navigate to the associated contact, company, or field.

***

## What happens when you run low on credits

* When you’ve used **90% or more** of your monthly credits, the credit indicator in the sidebar will turn **yellow** as a warning.
* Once you’ve **fully used up your credits**, FirstQuadrant will **no longer generate action items**. You can still:
  * View and accept previously generated actions
  * Use the platform’s navigation and views

However, you **won’t be able to generate or approve any new AI-generated suggestions** until:

* Your billing period resets, or
* You upgrade your plan (see the Subscription Settings article for details)

***


# Subscription and invoices
Source: https://docs.firstquadrant.ai/product-manual/billing-settings/subscription-invoices

Manage your subscription, billing details, and invoices in FirstQuadrant’s Billing settings. Update your plan, view past invoices, change payment methods, or cancel your subscription. Workspaces are permanently deleted seven days after a canceled subscription ends.

The **Subscription** settings in FirstQuadrant let you manage your plan, AI credit allocation, billing details, and invoices—all in one place. You can find this section by navigating to:

**Settings → Billing → Subscription**

## Current subscription overview

At the top of the page, you'll see a summary of your active subscription. This includes:

* Your **current plan** (Startup, Scaleup, or Enterprise)
* Your **billing period** (Monthly or Yearly—with a 15% discount on annual billing)
* Your **monthly AI credit allocation**
* The **price per month** based on selected credits and plan

If you want to switch plans, simply choose a new one from the list and click **Update plan**.

To compare plans in detail, click on **Compare plans**, which links to the pricing overview on the FirstQuadrant website.

## Change billing details

To update your billing address, payment method, or view your full billing profile, click the **Open billing portal** button. This will take you to the Stripe-powered billing portal.

In the Stripe portal, you can:

* View or change your payment method (for example, add a new credit card)
* Update your billing address
* Access a complete invoice history

## Invoices

To review your past invoices, go to:

**Settings → Billing → Invoices**

You'll see a list of all previously generated invoices, including:

* Date
* Invoice number
* Amount charged
* Status (for example, Paid)

Clicking on any invoice opens a detailed Stripe-hosted page where you can download the invoice or receipt.

## Canceling your subscription

At the bottom of the Subscription tab, you'll find the **Cancel subscription** button under the Danger zone. Clicking this will stop future billing and deactivate your plan after the current billing cycle ends.

After your subscription is cancelled and once the billing period runs out, FirstQuadrant will permanently delete the workspace after seven days. Be sure to export any important data before that deadline if you plan to cancel.


# Bulk edits
Source: https://docs.firstquadrant.ai/product-manual/bulk-edits

This article explains how to perform bulk edits in FirstQuadrant. It covers how to select multiple items in list views, how to access the footer edit bar, and what types of bulk edits are available depending on the list context (e.g., imports, contacts, deals).

Bulk edits in FirstQuadrant allow you to efficiently manage multiple items at once across various list views. Whether you’re working with imports, contacts, companies, deals, or campaigns, you can update multiple records simultaneously through a simple multi-selection interface.

## How to select multiple items

1. **Hover to reveal checkboxes**: When you're in a list view (e.g., imports, contacts, actions), hover your cursor to the far left of a row to reveal a checkbox
2. **Select multiple rows**:
   * Click a single checkbox to select that item
   * Hold **Shift** and click another checkbox further down the list to select a range of rows at once

## Available bulk edits

Once you’ve selected multiple items, a **footer navigation bar** will appear at the bottom of the screen. The available bulk edit options vary depending on the type of list you’re working with.

> **Note:** Bulk edits are context-specific. The options you see in the footer will depend on the list type you're in (e.g., contacts, deals, campaigns, etc.).


# Select sender and audience
Source: https://docs.firstquadrant.ai/product-manual/campaigns/add-sender-and-audience

Learn how to configure sender accounts and define your target audience when setting up a new campaign in FirstQuadrant. This guide walks through selecting the right email addresses for sending and building your audience using views and imports—two critical steps to ensure high deliverability and precise targeting.

## Step 1: Select sender accounts

### What are senders?

Sender accounts are the email addresses from which campaign messages will be sent. Each team member in FirstQuadrant can connect multiple email accounts, and you can selectively choose which ones to use per campaign.

### How to select senders

1. Go to the **Campaigns** tab
2. Click **New campaign** in the top-right corner
3. In the "Senders" section, click **Edit senders**
4. Click **Add sender** to assign team members
5. For each team member added, all connected email addresses will appear in a list
6. Use the toggles to activate/deactivate each email account for this campaign

> **Recommendation**: For outbound campaigns, avoid using your primary company domain (e.g., [name@yourcompany.com](mailto:name@yourcompany.com)) to preserve domain health and deliverability.

### How to add email accounts

Email accounts must be connected at the workspace level before they can be used in a campaign.

1. Go to **Settings** > **Integrations** > **[Email accounts](/product-manual/integrations-settings/email-accounts)**
2. Add one or more email addresses per team member
3. Configure settings via the advanced email account settings:
   * Daily sending limits
   * Ramp-up durations
   * Sending schedules

> **Note**: There is a dedicated helpdesk article that explains these settings in more detail, including best practices for deliverability and how sending limits are distributed. See the [Email Account Setup Guide](/product-manual/integrations-settings/email-accounts) for more information.

FirstQuadrant will automatically load balance the email volume across selected accounts to optimize distribution and minimize spam risk.

***

## Step 2: Define the audience

### What is an audience?

The campaign audience consists of the contacts who will receive the emails. You build your audience by assigning one or more "views"—saved filters or segments of your contact database.

### How to define your audience

1. After configuring senders, click on **Edit audience**
2. Click **Add views**
3. Choose one or more saved views from the dropdown
4. Optionally, create a new view directly from this screen
5. You can also add an import directly from here to target recently added contacts
6. To remove a previously selected view, re-open the **Add view** dropdown in the top-right and simply deselect it by clicking on it again

> Note: Both **[views](/product-manual/records/views)** and **[imports](/product-manual/imports/imports-overview)** are explained in detail in separate helpdesk articles.

### Managing individual contacts

* **Remove a contact from a campaign**: Click the three-dot menu next to the contact and select **Delete**
* **Add a contact manually to a campaign**:
  1. Go to the contact's profile
  2. Click the three-dot menu in the footer bar
  3. Select **Add to campaign** and choose the relevant campaign

***

With both sender accounts and audience defined, you're ready to proceed to Step 3: setting up the sequence.


# Advanced campaign settings
Source: https://docs.firstquadrant.ai/product-manual/campaigns/advanced-campaign-features

This article explains how to configure advanced settings for a specific campaign in FirstQuadrant, including pipeline selection, product or service customization, and sending schedule overrides.

When setting up a campaign in FirstQuadrant, you can customize the campaign beyond the standard flow by accessing the advanced settings. These advanced options allow for greater control over how deals are created, which product information is used in your messaging, and how email scheduling is managed.

To access advanced settings, click the **Advanced** dropdown in the campaign setup screen.

***

## Advanced options overview

### 1. Pipelines

By default, FirstQuadrant automatically creates a deal when someone replies positively to an email in your campaign. The AI determines the appropriate [pipeline](/product-manual/workspace-settings/pipeline-workspace-settings) based on the context and your existing pipeline structure.

However, if you have multiple pipelines set up, you can override this behavior:

* Uncheck “Use all pipelines”
* Select one or more pipelines to apply specifically to this campaign

This ensures all resulting deals from this campaign are created in the correct pipeline(s).

***

### 2. Product or service

FirstQuadrant uses your workspace's default company description and website when generating emails. This information is configured in your [workspace settings](/product-manual/workspace-settings/general-workspace-settings).

If you’re running a campaign for a specific product or offering, you can override this:

* Uncheck “Use default product or service details”
* Customize the name, description, and website as needed

This helps the AI generate more tailored and relevant messaging for that campaign.

***

### 3. Sending schedule

Campaigns typically follow the default sending schedule defined at the workspace level. However, you can create a unique schedule for a specific campaign:

* Uncheck “Use default sending schedule”
* Customize days and time windows during which emails should be sent
* Schedule can be defined relative to the **recipient's time zone**

This is useful if you want to experiment with different outreach timings or target specific regional behaviors.


# Campaign overview
Source: https://docs.firstquadrant.ai/product-manual/campaigns/campaign-overview

This article explains what campaigns are in FirstQuadrant, when to use them, and how to interpret the campaign overview interface. It covers the difference between draft and running states, breaks down progress tracking, and details how to stop a campaign using soft-stop or hard-stop options.

## Introduction

Campaigns in FirstQuadrant are used for sending personalized sequences of emails to a large group of contacts. They are ideal for outbound outreach, customer reactivation, and broad announcements—any situation where tight control over messaging and timing is required.

***

## What is a campaign?

A **campaign** is a powerful tool for reaching multiple contacts at once with a series of emails. It allows your team to design, schedule, and personalize mass outreach while maintaining control over the content and flow.

Campaigns can be used for:

* **Outbound prospecting**—reaching brand-new leads you've never spoken to
* **Customer reactivation**—re-engaging segments that have gone cold
* **Announcements**—broadcasting important updates such as product launches

Campaigns should always be used when you want to send a sequence of emails to a broad group of people with personalized messaging and timing control. Every campaign in FirstQuadrant ultimately aims to generate deals—once someone replies with interest, a [deal](/product-manual/records/records-overview) is automatically created.

***

## Campaigns overview page

When you navigate to the **Campaigns** section from the sidebar, you're brought to the overview page. This lists all existing campaigns along with the following columns:

* **Name**: The campaign title
* **Status**: Indicates whether the campaign is in "Draft" or "Running" state
* **Progress bar**: Displays visual breakdown of campaign status

### Campaign status

Campaigns can be in one of two states:

#### Draft

No emails are currently being sent. This includes new campaigns or paused ones.

#### Running

Emails are currently being sent to contacts in the campaign.

### Progress bar breakdown

Each campaign has a progress bar divided into four segments:

* **Completed**: All emails in the sequence have been sent
* **Running**: Some emails in the sequence have been sent; others are pending
* **Draft**: Emails are drafted but not yet sent to these contacts
* **Backlog**: Contacts are added, but email drafts have not yet been generated

Hovering over the progress bar shows the exact number of contacts in each state. This provides visibility into how the campaign is performing and whether additional contacts need to be added.

***

## Stopping a campaign

You can stop any running campaign by toggling it off. When doing so, you’ll be prompted to choose one of two options:

### Soft-stop

No new sequences will be initiated. However, sequences that have already started (i.e., at least one email has been sent) will continue until completed.

### Hard-stop

All sequences are terminated immediately. Even ongoing email sequences are interrupted, and no additional emails will be sent.

***


# Creating email sequences
Source: https://docs.firstquadrant.ai/product-manual/campaigns/create-sequence

Learn how to build and configure email sequences in FirstQuadrant campaigns, including writing messages, setting follow-up logic, using AI-driven variables, enriching with custom properties and knowledge, previewing personalized content, running A/B tests, and enabling smart automation settings like Autopilot and contextual adjustments.

## Adding your first message

When you reach the **Sequence** step in campaign setup, you'll be prompted to add a first message.

* Click **Add first message** to start from a blank template
* Alternatively, click the ✨ icon next to the button and choose between three AI-generated sequence styles:
  * **Friendly**
  * **Professional**
  * **Concise**

These presets will auto-generate an initial message along with up to two follow-ups.

***

## Structuring your sequence

You can add unlimited follow-ups to any sequence.

* For each follow-up, specify the delay in **days** after the previous message
* For the very first message, you can define when it should be sent after a contact enters the campaign audience (e.g., immediately, after 2 days). This is useful if contacts are added via integrations like a sign-up form and you want to delay outreach

***

## Personalizing content with variables

FirstQuadrant supports **AI-powered variables** that allow you to deeply personalize your sequence messages with dynamic content tailored to each contact or company.

To create a variable, type any instruction within curly brackets (`{}`) directly into your message draft. This tells FirstQuadrant to dynamically replace the placeholder with personalized content at send time. For example:

```
Hi {first name}, I came across {company name} and noticed you're working on {describe what the company is working on and why it matters}.
```

When you add a variable to your message, it will automatically appear in the **Variables** panel on the right-hand side of the sequence editor. There, you can:

* View and edit the variable name
* Add **example values** to guide the AI (e.g., "scaling global logistics")
* Select the **expected length** of the output:
  * Very short (2–3 words)
  * Short (4–5 words)
  * Medium (1 short sentence)
  * Long (1–2 sentences)
  * Auto (let the AI determine)

The quality of the AI-generated content depends on the information available to FirstQuadrant. A variable can be powered by:

* **Public data** the platform automatically collects (e.g., LinkedIn bios, Crunchbase descriptions)
* **Properties** enriched through AI or manually added (see the "Adding custom properties" section)
* **Knowledge** added via fine-tuning (see the "Adding knowledge" section)

For instance, if you use a variable like `{mention similar companies we've worked with}`, FirstQuadrant can only fill this out accurately if you've added a fine-tuning rule listing relevant companies.

> **Tip:** Always ensure the content you want to reference in your variable is available in one of these sources. If not, add a property or create a fine-tuning rule to feed the AI the context it needs.

This approach allows you to craft structured email sequences where you control the narrative, while still dynamically adjusting language, tone, and examples for each recipient.

***

## Adding knowledge

To help the AI personalize sequences using your internal knowledge base, you can create **contextual knowledge blocks** that serve as additional training for the model.

1. Scroll down to the **Knowledge** section in the right-side context panel while editing your sequence.
2. Click **Add knowledge** to open a modal.
3. In the modal:
   * **Define a topic**—this is a label for internal use (e.g., "Pricing", "Use cases", "Customer success stories")
   * In the **Knowledge field**, write out detailed background information that you'd like the AI to reference. This can be anything from pricing breakdowns, competitive differentiators, case studies, customer references, or internal positioning notes
   * This content is treated as factual and instructive, so make sure it is accurate and clearly written

### Where and how the knowledge is used

Once added, the knowledge becomes part of the context that the AI will reference when generating or filling in variables inside your campaign sequence. For example, if your email draft includes a variable like:

```
{mention a pricing detail relevant to startups}
```

The AI will scan the knowledge you added and use that to fill in an appropriate line (e.g., "Starts at \$1,000 per month with a 50% discount for YC startups").

> If your knowledge content includes a list (e.g., of companies you've worked with, or common objections), the AI can pick the best-matching items depending on the contact's context (like industry or job title).

### Knowledge scope

By default, the knowledge you add will be scoped to the current campaign only. This ensures maximum relevance. If the content is broadly useful, you can instead check the option to make it **globally available**, allowing the AI to apply it across all campaigns and sequences.

> **Tip:** The more structured and specific your knowledge content is, the more reliably the AI can use it in context. Use bullets, examples, and segment-specific notes wherever possible.

***

## Adding custom properties

To capture extra context for contacts or companies:

1. Scroll to the **Properties** section in the right panel
2. Click **Add property**
3. Choose whether the property applies to a **Contact** or **Company**
4. Set the type (e.g., Text, Checkbox, Multi-select)
5. Choose how to enrich the property:
   * Use AI (e.g., Perplexity)
   * Use your internal data

These properties are essential to ensure that variables can be filled accurately by the AI. For example, if you use a variable like:

```
{if it’s a YC company tell them that they get 50% off otherwise say nothing}
```

The AI needs access to a property that clearly indicates whether the recipient’s company is in Y Combinator or not. If such a property hasn’t been added and enriched, the AI won’t be able to evaluate the condition, which could lead to missing or incorrect content in the final message.

> Note: A separate helpdesk article explains how to configure and manage properties in full detail. Refer to it if you're unsure how to define or enrich properties effectively.

In short, properties act as structured inputs that power conditional logic and dynamic personalization in your message templates.

***

## Creating A/B test variants

You can test multiple variations of your email sequence:

* Click **A/B testing** at the top right
* Select a predefined AI tone (Friendly, Professional, Concise), or choose **Custom** to write your own
* Each variant will be distributed evenly to your campaign audience
* View analytics later to see which variant performs best and disable the rest

***

## Previewing your sequence

Click **Preview** to simulate exactly how your sequence emails will look for each contact and sender combination. This is a critical step to ensure your variables are resolving correctly, your tone is consistent, and that the AI has all the context it needs.

Once in preview mode, FirstQuadrant will automatically load a contact from your campaign audience. You can:

* Use the **Next** button to cycle through different contacts in the audience
* Click the **three-dot menu** next to the contact preview to search for and select a specific contact
* Preview how the message will render for **each team member** by switching the sender using the dropdown in the top-right. This is especially useful if you've enabled dynamic variables or sender-specific content

Every variable in the email will be filled with live data:

* If the AI is missing any variable context (e.g., a property is not enriched), you'll see the variable unresolved or blank
* If knowledge or fine-tunings are involved, the preview will show how the AI interpreted that input

This allows you to:

* Iterate on your variable instructions (curly bracket prompts) if the results aren't consistent
* Adjust knowledge or property inputs if the data pulled is too vague or too generic

> **Tip:** This preview not only helps avoid embarrassing mistakes, but it's also the best way to test AI behavior under real conditions before your campaign goes live.

***

## Optional settings

Located in the right-side panel of the sequence editor, these settings give you control over automation, personalization, and deliverability behaviors.

### Autopilot

When Autopilot is turned **on**, FirstQuadrant will send out email sequences automatically without requiring your manual approval via the Actions List.

* By default, Autopilot is **disabled**, meaning all outbound messages generated from your campaign will first be listed in your Action List for review and approval
* If you **enable Autopilot**, a sub-setting called "Disable for contacts with existing conversation history" is automatically turned **on**. This means:
  * Sequences **will not be automatically sent** to contacts who have prior email history with anyone in your team—instead, they will be added to your Action List for manual review and approval
  * This helps prevent awkward situations, such as sending a cold email to someone you already had a relationship with
  * You can disable this sub-setting if you're confident the sequence is appropriate even for known contacts

### Contextual adjustment

This setting is **enabled by default**. It allows FirstQuadrant’s AI to intelligently rewrite parts of the email based on previous conversations.

For example:

* Instead of saying "I just came across your company," the AI might rewrite it to say, "It's been a while since we last connected," if there's past communication
* This setting ensures your messages feel relevant and human, especially when your campaign includes a mix of new and previously engaged contacts

### Open tracking

Open tracking allows FirstQuadrant to measure how many of your sent emails are being opened, using an invisible tracking pixel.

By default, FirstQuadrant uses **sampled tracking**:

* The tracking pixel is injected into only about **10%** of emails to protect deliverability
* FirstQuadrant uses this sample to **extrapolate** overall open rates
* This approach avoids spam filters that penalize campaigns with excessive tracking

Alternatively, you can enable **full tracking** in your workspace settings:

* When enabled, a tracking pixel is included in **every email** for precise, per-email open data
* Provides maximum visibility into individual email engagement
* May slightly impact deliverability rates

Open rates can be viewed inside the **Campaign Analytics** dashboard for each campaign. The tracking mode (sampled or full) is determined by your workspace's Schedule & Tracking settings.

***

## Finalizing the campaign

Once your sequence is set up:

1. Click the **X** in the top left to close the editor
2. Return to the campaign overview
3. Toggle the campaign **on** in the top-left corner

Your campaign will now begin executing as configured.


# Contact view
Source: https://docs.firstquadrant.ai/product-manual/contact-view/contact-view

The contact view in FirstQuadrant provides a unified interface that combines a full conversation history with detailed contact and deal context. It helps sales reps stay organized, informed, and ready to act—all in one screen.

## Main components of the contact view

### Conversation history (middle section)

This is the central area of the contact view and serves as a chronological feed of all communication and AI-generated drafts. Learn more about the [conversation history](/product-manual/contact-view/conversation-history).

### Context panel (right section)

This section provides relevant information about the contact and the associated deal, so users don't have to switch views. See the [context panel](/product-manual/contact-view/context-panel) documentation for details.

### Top-right "..." menu

The top-right menu (three dots icon) in the context panel gives users access to several administrative actions:

* **Archive contact**\
  Marks the contact as archived. FirstQuadrant will no longer run AI reasoning on any future emails or notes, and will not create any drafts or tasks for this contact.
* **Delete contact**\
  Permanently removes the contact from FirstQuadrant
* **Copy contact ID**\
  Copies the internal contact ID to clipboard—useful for debugging or internal references
* **Copy item as JSON**\
  Allows you to copy the contact record in structured JSON format, which is useful for troubleshooting or exporting
* **Copy**\
  Creates a duplicate of the contact record

### Summary

If available, there will be a "Summary" button that you can press to see the summary of the conversation history so far. This will give you a quick glance at everything that's happened, so that you don't have to read out the entire conversation history.


# Context panel
Source: https://docs.firstquadrant.ai/product-manual/contact-view/context-panel

The context panel in FirstQuadrant provides enriched, editable insights into each contact, their company, and any associated deals. It supports both users and the AI by offering structured data, related contacts, and custom properties to personalize engagement and streamline workflows.

## Structure of the context panel

The context panel is located on the right side of the contact view and is divided into three main sections:

### Deal section

If there's a deal linked to the contact, the following information is displayed (as available):

* **Status** (e.g., Open, Won, Lost)
* **Pipeline** (which pipeline the deal is part of)
* **Stage** (current stage in the pipeline)
* **Value** (deal value in USD or any relevant currency)
* **Name** (deal name, only visible when different from the company name)
* **Owner** (team member responsible for managing the deal)
* **Points of Contact** (contacts associated with this deal)

Please note that some of these fields are only visible when you are looking at a specific deal or company, but not from the overview page such as Actions and Contacts.

You can hover over this section to access a three-dot menu:

* **Rename the deal**
* **Delete the deal**
* **Copy the deal name**

All deal fields are directly editable by hovering and clicking.

***

### Deal participants

#### Assigning deal owners

1. Click on the current owner's name or avatar
2. Search for a team member in the dropdown
3. Select the new owner to reassign the deal

#### Managing points of contact

1. Click "Add point of contact" (+) to associate contacts with the deal
2. Select from existing company employees or create a new contact
3. Remove contacts by clicking the Delete icon on their avatar

**Display behavior:** When more than 4 contacts are associated with a deal, the first 4 are displayed with a "+X" button that shows the remaining contacts in a tooltip on hover.

***

### Contact information section

Displays (depending on enrichment quality):

* Contact's full name
* Status (Active, Inactive)—see the article [Understanding contact status](/product-manual/active-inactive-contacts) for details on what these statuses mean and how they're determined
* Job title and company
* Location and time zone
* Linked social profiles (LinkedIn, GitHub, etc.)
* Work history (automatically enriched)
* Email address
* Phone number (if available)

This data is enriched on-demand when FirstQuadrant determines it's needed (e.g., when the contact is added to a campaign, send an email, or when other activities occur). The enrichment process pulls data from multiple public and commercial sources. While mostly accurate, it's not guaranteed to be 100% correct. You can manually override any field by clicking and editing directly.

***

### Company information section

Displays (as available):

* Company name, logo, and description
* Website and social links
* Headquarters location
* Year founded
* Revenue, funding, employee count
* Industry tags
* Languages and tech stack

Just like contact info, company data is enriched on-demand but fully editable.

#### Managing employments

You can manage a contact's employment information through the three-dot menu (...) next to the company information. This menu provides several options:

**Delete employment**

* Removes the contact from the current company
* Both the contact and company remain in the system
* Any deals associated with this employment will be removed

**Add another company**

* Allows the contact to be associated with multiple companies simultaneously
* Useful for contacts who work at multiple companies or have side projects
* Creates a new employment record without affecting existing ones

**Replace company**

* Changes the contact's primary company association
* Removes them from the current company and adds them to a new one
* Removes them from any deals associated with the current company
* Requires confirmation before proceeding

**Go to company**

* Navigates to the company's dedicated page for detailed management

> **Note:** When managing employments, consider the impact on associated deals and activities. Deleting or replacing employments may affect campaign targeting and deal tracking.

#### Adding companies to contacts without employments

When a contact doesn't have any company associations, you'll see a dedicated section that allows you to add their first employment:

1. **Locate the "Add employment" button** - This appears when a contact has no company associations
2. **Click "Add employment"** - This opens a company search interface
3. **Search for companies** - Use the search field to find existing companies in your workspace
4. **Select a company** - Click on the desired company from the search results
5. **Employment created** - The contact is now associated with the selected company

This feature is particularly useful for:

* Contacts imported without company information
* Manually created contacts that need company associations
* Contacts whose company information wasn't captured during enrichment

***

## Related contacts

Below the contact data, you'll see a **Related contacts** section. These are dynamically identified based on:

* Working at the same company
* Being part of the same email threads (e.g., CC'd)
* Mentioned in conversations with the contact

This allows you to:

* Quickly switch between related contacts
* Understand how conversations with one contact might influence others

> **Note:** For a deeper dive into how related contacts work and how they are determined, refer to the article: [Understanding related contacts](/product-manual/related-contacts). It includes examples and best practices for using this feature effectively.

***

## Custom properties

You can add new properties to either:

* The contact
* The company

These are useful for:

* Adding custom data (e.g., CRM ID, preferred channel, referral source)
* Enabling segmentation and personalization
* Feeding the AI richer data for email generation and automation

You can add predefined field types (e.g., social links) or create entirely custom fields and enrich them using AI.

> **Note:** For more details on how to use properties effectively, see the article [Using custom properties](/product-manual/properties/properties). It covers how to structure properties for segmentation, personalization, and automation workflows.

***

## AI access and usage

All data in the context panel is also accessible by FirstQuadrant's AI. This enables the AI to:

* Personalize outreach and follow-ups based on job role, company, etc.
* Use deal stage/value to guide urgency or tone
* Leverage related contacts for multi-threaded engagement

Keeping this information accurate improves AI performance significantly.

***

## Pending enrichment

When you see "Pending enrichment" in the context panel, it means that FirstQuadrant has not yet enriched the contact with additional information from external sources.

### When enrichment happens

FirstQuadrant intelligently enriches contacts when there's a specific reason to do so, such as:

* When a new email is received from the contact
* When a sequence is being created in a campaign
* When a task is completed for the contact
* When the contact starts nurturing
* When any other activity occurs that would benefit from enriched data

This smart enrichment approach ensures that FirstQuadrant only invests resources in enriching contacts when there's a clear business need, rather than enriching every contact immediately upon creation.

### Manual enrichment options

While waiting for automatic enrichment, you have two options:

1. **Add information manually**: You can directly edit any field in the context panel to add or update contact information
2. **Trigger immediate enrichment**: Click the "Enrich contact" button to manually trigger the enrichment process immediately

> **Note:** Even when enrichment is pending, you can still use all other features of FirstQuadrant normally. The contact will be enriched automatically when the system determines it's necessary for your workflow.


# Conversation history
Source: https://docs.firstquadrant.ai/product-manual/contact-view/conversation-history

This document explains how the conversation history works within the contact view in FirstQuadrant. It outlines how emails, notes, calendar events, and AI-generated items are unified into a single, chronological timeline across your entire team. It also details how FirstQuadrant automatically syncs all past and present communications with a contact and allows users to hide irrelevant messages from both the view and the AI’s logic.

## Overview

The **conversation history** is the central section of the contact view in FirstQuadrant. It provides a unified, chronological timeline of all interactions related to a specific contact, across your entire organization. This includes emails, calendar events, AI-generated items, and internal notes—regardless of who on your team was involved.

## How it works

When a contact is added to FirstQuadrant, the platform syncs **all past and future emails** related to that contact from connected mailboxes. This includes:

* Emails from the assigned contact owner
* Emails from *any* team member who has interacted with the contact
* Emails where the contact was either the main recipient or just **CC’d**

This creates a **team-wide, organization-level** view of all communication, ensuring complete context even if conversations occurred years ago or with different team members.

## Unified, continuous timeline

Unlike traditional email clients that group messages by subject into threads, FirstQuadrant displays all communications as a **single, continuous timeline**. While subject lines can still be added (for the recipient’s inbox experience), within FirstQuadrant everything appears in one flowing view. This allows you to easily trace the full relationship history without fragmentation.

## What is included

The conversation history includes:

* **All synced emails** (sent, received, CC'd)
* **[Internal notes](/product-manual/notes)** added by team members (which can be displayed as collapsed event snippets or full notes, depending on import settings)
* **Calendar events** (e.g. meetings scheduled)
* **AI-generated drafts and tasks** such as:
  * Suggested follow-ups
  * Draft replies
  * Deal updates
  * Snippets summarizing actions taken by the AI

This offers full visibility into all activities tied to a contact.

## Hiding messages

You can **hide specific emails** from the conversation history by clicking on them and selecting the hide option. Hiding an email does two things:

1. Removes it from your view
2. Excludes it from FirstQuadrant's AI decision-making

This is helpful when irrelevant or off-topic emails should be ignored in future planning.

You can later **restore hidden messages** using the filter settings to show hidden items.


# Manual actions
Source: https://docs.firstquadrant.ai/product-manual/contact-view/manual-actions

This article explains how to use the footer bar in the contact view of FirstQuadrant to manually take actions such as composing emails, writing notes, creating follow-ups, adding contacts to campaigns, or initiating nurturing flows. It also covers how notes influence AI reasoning and how the footer bar adapts based on whether next actions are already planned.

### Overview

In the contact view of FirstQuadrant, the **footer bar** (bottom navigation bar) provides access to all manual actions you may want to take for a specific contact—regardless of whether there are [AI-generated next actions](/product-manual/contact-view/next-actions) queued. This makes it the central control panel for direct engagement, note-taking, or overriding the AI's default behavior.

## Manual actions available in the footer bar

The footer bar always presents the following options:

### Compose email

Clicking the **compose email** icon opens a drafting window where you can:

* Choose the sender address (if multiple mailboxes are connected)
* Send to the contact's email by default, or manually add others as CC
* Enter a subject and write your message manually or click **"Write with AI"** to let FirstQuadrant assist with drafting
* Send immediately or **schedule the email** for later via the dropdown

> **Note:** BCC is not currently supported.

### Add note

Selecting **Add note** opens a text box where you can write any internal note.

Notes serve two functions:

* **Internal memory**: So you and your team can record context or outcomes from calls or meetings
* **AI instruction**: FirstQuadrant will process your note and, if relevant, may generate appropriate next steps (e.g., scheduling a follow-up email after a vacation or triggering a deal stage update)

> **Example:** Writing a note like “Spoke to Brian at the café, he’s on vacation until next week” might lead the AI to automatically draft an email for his return.

### Regenerate

The **regenerate** icon allows you to run the AI process again on the current contact. This can be useful if new information has come in and you want the AI to re-evaluate what the next best step should be.

### Additional options via the “...” menu

Clicking the three-dot icon reveals extended manual actions:

* **Delete action**: Remove any existing drafted next action
* **Create follow-up**: Manually draft an additional follow-up sequence
* **Add to campaign**: Enroll the contact in an ongoing [outbound campaign](/product-manual/campaigns/campaign-overview)
* **Start nurturing**: Begin a more passive [engagement sequence](/product-manual/nurturing) if the contact is not currently hot

## Footer bar states

The footer bar layout varies slightly based on whether any AI actions are pending:

### When AI-generated actions are present

The primary CTA is **“Approve all”**, allowing you to bulk-approve suggested actions.

### When no actions are queued

The default CTA switches to **“Compose email”** and **“Add note”**, prompting more proactive manual outreach.

## Summary

The footer bar empowers you to take control when AI is not enough or when human nuance is required. Whether you want to manually nudge a contact, record a meeting outcome, or inject a lead into a campaign, all key tools are just a click away.

Use it to:

* Write and send emails manually or with AI support
* Capture and act on internal notes
* Manually shape your pipeline by overriding or supplementing AI behavior


# Next actions
Source: https://docs.firstquadrant.ai/product-manual/contact-view/next-actions

This article explains how FirstQuadrant automatically generates AI-driven next actions based on sales conversation activity. It outlines the types of actions FirstQuadrant can take (such as updating deals, sending replies, or creating tasks), how to review and edit these actions, and how to use tools like the bottom navigation bar and the Actions dropdown to manage your workflow. It also covers how to fine-tune the AI’s knowledge when it can’t answer a question, and how to snooze, regenerate, or approve actions efficiently.

## Overview

FirstQuadrant automatically analyzes any activity happening in a conversation between your workspace and a contact—such as emails, calendar invites, replies, signups, comments, notes, or API events. Based on this analysis, its AI determines the most logical next steps and generates what are called **next actions**. These actions are visible directly inside the conversation history view.

## What the AI can do

### Deal-related actions

* **Create a deal**
* **Update an existing deal**, such as:
  * Reassigning to a different pipeline
  * Moving to a different stage
  * Changing deal status
  * Assigning a new point of contact to the deal

### Contact and company-related actions

* **Update contact fields** based on incoming messages (e.g., name, job title, location)
* **Update company fields** based on available data (e.g., company name, industry, description)

### Conversation-related actions

* **Write emails**, including:
  * Immediate replies
  * Scheduled replies
  * Replying either to the individual sender or using 'Reply all' based on the context of the conversation\
    → The AI reads the full thread to determine whether other recipients should be included, and makes a judgment call on whether a group response is appropriate
* **Create follow-ups** as a sequenced series of emails
* **Create tasks** when human intervention is needed
  * E.g., if a prospect requests a PDF quote, the AI will generate a task for the user to upload it

Each action includes its own AI-generated reasoning, which can be viewed by hovering over the tooltip icons in the UI. This helps you verify whether the AI's decision-making aligns with your expectations.

### Deal monitoring and fallback logic

If a deal has no actions scheduled or drafted for more than **three days**, FirstQuadrant’s AI will automatically mark the deal as potentially stalled. In this case, the system will:

* Flag the deal as stale
* Generate a task for a human to intervene

The task will prompt the user to either:

* Mark the deal as lost
* Set up additional follow-ups
* Or take any other custom action to re-engage or close the loop

When FirstQuadrant detects an event or update in the contact relationship, it can perform or propose several types of actions:

## Types of actions

| Action Type     | Description                                                          |
| :-------------- | :------------------------------------------------------------------- |
| **Reply now**   | Immediate email response                                             |
| **Reply later** | Scheduled email to be sent in the future                             |
| **Follow-ups**  | Email sequence planned across multiple days                          |
| **Task**        | Manual item for a human to complete before the workflow can continue |

## Editing and approving actions

### Adjusting fine-tuning rules per email

You can click on the colored label (e.g., "Negative", "Positive", "Postponed") shown above an email to open the [fine-tuning settings](/product-manual/fine-tuning/fine-tuning-overview) for that specific message. This lets you:

* See which fine-tuning rule(s) were automatically applied by the AI
* Select or deselect rules to manually override the AI’s classification
* Regenerate the next actions based on the adjusted rule set

This is especially useful when the AI misunderstood the tone or content of an email and you want to guide it toward a better response.

Each suggested action appears as a draft in the conversation timeline. The main way to work with these next actions is through the **footer bar**, which appears at the bottom of the screen when viewing an active contact. This navigation bar includes the following primary controls:

* **Approve all**: Approves all listed actions at once. Any email scheduled to be sent immediately will go out, while the others will be queued according to their planned time
* **Snooze**: Temporarily defers all current actions. Snoozed actions are removed from the action list and marked as "later." They will automatically reappear after the selected duration (e.g., 1 day, 1 week, or 1 month)
* **Regenerate**: Reruns FirstQuadrant's AI on the entire contact history to generate a new set of actions. This will consume credits
* **Delete**: Accessible via the extended menu (three dots), this removes all current actions from the list if you want to start fresh or discard what's been planned

### Working with individual actions

#### Using the Actions dropdown

You can click the **Actions** dropdown directly within the conversation timeline. This pop-up menu allows you to:

* Add or remove specific action types (e.g., reply now, follow-ups, tasks)
* Change an existing action type
* Insert knowledge entries for AI fine-tuning if a question couldn't be answered

> **Tip:** If the AI can't answer a contact’s question, it may create a task asking for manual input. Once you provide the answer, you can save it to the knowledge base via the fine-tuning panel. This enables FirstQuadrant to handle similar questions automatically in the future.

#### Manually editing individual actions

Or you can edit individual action items manually:

* **Edit the email content** manually or use the “Write with AI” feature to generate or revise content. You can also update the metadata (sender, recipient, subject)
* **Modify the sending time** using the dropdown
* **Approve** an individual action
* **Delete** any draft you find unnecessary
* **Snooze** the actions (1 day, 1 week, or 1 month)
* **Regenerate actions**, which reprocesses the entire contact thread and recalculates AI actions (uses credits)


# Data management settings
Source: https://docs.firstquadrant.ai/product-manual/data-management-settings

This article provides an overview of the Data Management settings in FirstQuadrant, covering how to manage custom properties, view and access deleted contacts, export contact data, and review system activity through the audit log.

The Data Management section in FirstQuadrant provides a centralized view and control over your custom properties, deleted contacts, data exports, and system audit history. These tools are essential for managing your CRM data efficiently and maintaining clean, actionable records.

## Properties

The **Properties** tab lists all the custom properties that have been added to your workspace—these can be used to enrich contact and company records. Properties can be of different types (e.g., checkbox, text, multi-select) and are often enriched with AI.

* To add a new property, click **New property** in the top-right corner.
* To edit an existing property, click on it directly in the list.
* To delete a property, click the three-dot menu (`...`) on the right of the property row and select **Delete**.
* You can also copy a property from the same menu.

> **Info:** For a full guide on what properties are and how to create and use them, see the [respective article](/product-manual/properties/properties).

## Data export

The **Data export** tab allows you to download all your contact data from FirstQuadrant in one click.

* It includes contact details such as emails, LinkedIn handles, and other associated IDs.
* Simply click the **Download** button to retrieve the export file.

## Audit log

The **Audit log** displays a time-stamped activity log of all major system events and user actions within your workspace. This includes:

* Contact creation and deletion
* Import activity
* API key creation
* Pipeline changes
* Tracking domain updates

Each log entry includes:

* The date of the event
* The type of event
* The associated object ID
* The IP hash
* The agent (browser and OS used)

This is particularly useful for security reviews, troubleshooting, and internal audits.


# Developer settings
Source: https://docs.firstquadrant.ai/product-manual/developer-settings

Learn how to manage developer settings in FirstQuadrant, including how to create and monitor API keys for integrations, configure domains for email tracking, and verify DNS records for improved deliverability.

FirstQuadrant’s **Developer Settings** section allows technical users to extend and integrate the platform through API keys, domain configuration, and webhook consumers. These tools enable external automation, secure tracking, and deeper custom integrations.

***

## API keys

API keys let you authenticate and interact with the FirstQuadrant API programmatically. This is useful for automating workflows, syncing contacts or deals from third-party platforms, or triggering specific actions via scripts or custom tools.

### How to create an API key

1. Navigate to **Settings > API keys** under the **Developers** section.
2. Click **New API key** in the top right corner.
3. Enter a name for your API key (e.g., "Zapier Sync", "CRM Integration").
4. Click **Create API key**.

Your new API key will appear in the list. You can monitor the **Last usage** field to check whether the key has been used in any recent API call.

### Managing API keys

* To **delete** a key, use the … menu on the right and click **Delete**.
* Only unused or no-longer-needed keys should be deleted to maintain security.

***

## Domains

Domains are used to configure tracking for opens and clicks when sending emails via FirstQuadrant. Verifying a domain ensures better deliverability and branding.

### How to add and verify a domain

1. Go to **Settings > Domains** under the **Developers** section.
2. Click **New domain** on the top right.
3. Enter your sending domain (e.g., `example.com`).
4. Follow the instructions shown to add the required **CNAME** record to your DNS provider:
   * **Type:** CNAME
   * **Name:** `fq`
   * **Value:** `prox.fqtrack.com`
5. Once the record is live, return to the Domains view and click **Verify**.

Domains that are successfully verified will be marked as such. If verification fails, double-check your DNS records and try again.

### Managing domains

To delete a domain:

* Click the three-dot menu next to the domain entry and select **Delete**.

***


# Downloading desktop app
Source: https://docs.firstquadrant.ai/product-manual/downloads

Learn how to download and install the FirstQuadrant desktop app for macOS, Windows, and Linux using the universal or platform-specific installers.

You can install the FirstQuadrant desktop app for macOS and Windows from our official downloads page:

<Check>[https://firstquadrant.ai/download](https://firstquadrant.ai/download)</Check>

Here are the specific URLs for each operating system:

| Operating System      | Download Link                                                                                                                  |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| All                   | [Universal installer](https://dl.todesktop.com/240316rr0owjjqj)                                                                |
| macOS (Apple Silicon) | [DMG](https://dl.todesktop.com/240316rr0owjjqj/mac/dmg/arm64) or [ZIP](https://dl.todesktop.com/240316rr0owjjqj/mac/zip/arm64) |
| macOS (Intel)         | [DMG](https://dl.todesktop.com/240316rr0owjjqj/mac/dmg/x64) or [ZIP](https://dl.todesktop.com/240316rr0owjjqj/mac/zip/x64)     |
| Windows               | [NSIS](https://dl.todesktop.com/240316rr0owjjqj/windows/nsis/x64)                                                              |
| Linux                 | [AppImage](https://dl.todesktop.com/240316rr0owjjqj/linux/appImage/x64)                                                        |


# Create fine-tuning
Source: https://docs.firstquadrant.ai/product-manual/fine-tuning/create-fine-tuning

Fine-tuning rules in FirstQuadrant allow you to customize the AI's behavior by defining how it should respond in specific scenarios. Rather than hard-coded if-statements, these rules act as flexible, natural-language instructions—like training an assistant. You can create fine-tuning rules for different input types, limit their scope to specific segments, and optionally enable Autopilot to automate actions without human approval.

## Types of fine-tuning rules

There are four types of fine-tuning rules:

### 1. Email rules

Used when the AI receives an email and needs to respond accordingly.

* Requires a **label** (e.g. "Time zone conflict") and a **color tag**.
* A **description** is automatically generated by the AI once you type the label. You can freely edit this.
  * This description helps the AI recognize when the rule applies. For example:
    * Label: "Postponed"
    * Description: "Any request to continue conversation at a later time. Includes both specific dates and indefinite delays."
* You must then provide **instructions** telling the AI what actions to take. These can include:
  * Reply content (e.g. "Send confirmation of postponement")
  * Workflow instructions (e.g. "Set reminder for follow-up at specified time")
  * Contact management steps (e.g. “mark as lost")

### 2. Note rules

Triggered when a note is added—either manually by a user or automatically via API.

* You only write **instructions**—no label or description needed.
* Example:
  * Instruction: "When meeting notes are added, always send an email summarizing key points."
  * API use-case: A signup note is added, and the AI sends a thank-you message with demo link.

### 3. General rules

Apply globally across FirstQuadrant.

* Only **instructions** are needed.
* Example use-cases:
  * "Always reply in Spanish when the recipient writes in Spanish."
  * "Use friendly tone-of-voice and concise language."
  * "Send confirmation email with Zoom link when a meeting is scheduled."

### 4. Knowledge rules

Enrich the AI’s contextual understanding of your sales environment.

* Define a **topic** (e.g. "Pricing")
* Add **knowledge** entries (e.g. "Starts at \$1,000/month; 50% off for YC startups for 3 months")
* These are referenced whenever the AI crafts replies to related inquiries.

## Defining scope

Each rule can be applied globally or scoped to a specific segment:

* **[Views](/product-manual/records/views)** (e.g. "All contacts", "Active deals")
* **[Campaigns](/product-manual/campaigns/campaign-overview)** (e.g. "CH Insurance CTOs - Outbound")
* **[Imports](/product-manual/imports/imports-overview)** (e.g. "All imports")

Use this setting to ensure that a rule only applies to a relevant subset of contacts.

## Creating a rule

To create a new rule:

1. Navigate to **Fine-tuning** in the sidebar.
2. Click **New rule** (top-right).
3. Select the rule type: Email, Note, General rule, or Knowledge.
4. Define the scope via the **Applies to** dropdown.
5. For Email rules:
   * Add a label and select a color.
   * Review and adjust the auto-generated description.
   * Write clear instructions (what should happen when the email is received).
6. For Note/General/Knowledge rules:
   * Skip the label and description.
   * Provide specific instructions (for Note and General) or contextual entries (for Knowledge).
7. Enable **Autopilot** (optional).
8. Click **Create fine-tuning rule**.

## Writing effective instructions

* Always write in clear, plain English.
* Instructions can define:
  * Email reply behavior (e.g. "Reply with apology and offer to reschedule")
  * CRM or deal changes (e.g. "Move deal to lost")
  * Actions (e.g. "Create task to follow up in 2 weeks")
  * Templates (e.g. full draft email with follow-ups)

## Autopilot mode

Email and Note rules support **[Autopilot](/product-manual/autopilot)**, which skips the Action List and is immediately executed:

* If only Autopilot-enabled rules apply to a given situation, the AI will execute them immediately.
* If multiple rules apply but one or more do **not** have Autopilot enabled, the action will appear in your list for review.

Use Autopilot carefully to automate trusted scenarios (e.g. out-of-office replies, time zone conflicts).


# Fine-tuning examples 
Source: https://docs.firstquadrant.ai/product-manual/fine-tuning/fine-tuning-examples

Fine-tuning rules in FirstQuadrant allow you to tailor the AI’s behavior in specific situations using natural-language instructions. These rules do not follow rigid logic, but instead guide the AI—much like training a smart assistant. You can scope each rule to specific contact segments and optionally enable Autopilot to let the AI act without approval.
This article provides practical examples of fine-tuning rules by type. For details on how to create a rule, refer to the fine-tuning rule creation guide.

## Email rules

| Label              | Description                                                              | Instruction                                                                                             |
| :----------------- | :----------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------ |
| Time zone conflict | When a contact is unable to find a suitable slot due to time differences | Ask the contact to share their calendar link instead; offer to schedule outside of regular office hours |
| Postponed          | Any request to continue conversation at a later time                     | Confirm postponement and create a reminder to follow up at the specified time                           |
| Counter-offer      | When someone replies to our outreach to sell *their* product             | Politely decline the offer, stop further follow-ups, and mark the deal as lost                          |

## Note rules

| **Example**                  | **Instruction**                                                                                                                                                                                                                                                                                       |
| :--------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Meeting notes                | When meeting notes are added, send a summary email to the contact with the key takeaways                                                                                                                                                                                                              |
| Website visitor (via Vector) | If a note indicates a visit to our site, don’t create a deal; instead, send an email asking if they’d like to see a demo. For example: “Hey `{{first name}}`, I noticed you visited FirstQuadrant AI earlier today. Would you be open for a quick demo? You can schedule directly here: \[demo link]” |

## General rules

| **Example**        | **Instruction**                                                                                                            |
| :----------------- | :------------------------------------------------------------------------------------------------------------------------- |
| Proactive emailing | Be slightly more aggressive when it’s unclear if one more email is justified. Better to send one too many than one too few |
| Language handling  | Always respond in the language the contact uses (e.g. “Reply in German if the contact writes in German”)                   |
| Follow-up behavior | Keep follow-ups short. In the final follow-up, ask if they can refer us to the correct person at their company             |

## Knowledge rules

| Topic                               | Entry                                                                                                                                                                        |
| :---------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Discount policy                     | Discounts available for certain segments. Never mention discounts unless asked. If the segment is known, share the discount and code. If not, ask for clarification          |
| Demo material                       | Demo video is available at \[demo link]. If asked for a demo, share this link                                                                                                |
| Free trial policy                   | We don’t offer free trials. Instead, we explain that the \$250 pricing is designed as a low entry point and shows the contact is serious. We offer proper onboarding instead |
| Competitor comparison               | Document key differences between us and each major competitor. Don’t mention competitors unprompted. If someone asks, reply based on this knowledge                          |
| General availability for scheduling | John Doe’s availability is any weekday between 9 AM and 5 PM PST.                                                                                                            |

### Additional notes

* Use clear, natural language in all instructions
* Email and note rules support Autopilot
* Refer to the fine-tuning overview for how these rules function behind the scenes


# Fine-tuning
Source: https://docs.firstquadrant.ai/product-manual/fine-tuning/fine-tuning-overview

Fine-tuning rules in FirstQuadrant allow you to customize how the AI behaves across various sales scenarios. These rules serve as high-level instructions—like guidelines for a smart assistant—not strict logic trees. They enable FirstQuadrant to reason through nuanced sales interactions while adapting to your unique sales process and language.

## What are fine-tuning rules?

Fine-tuning rules are written in plain English and used to:

* Teach the AI how to respond to specific messages or notes
* Control how the AI interprets information
* Define sales playbook behavior per contact segment
* Embed sales knowledge and objection handling

These rules are flexible and context-aware. The AI will follow them when reasonable but may deviate in edge cases or when multiple rules conflict.

## Rule types

Fine-tuning rules apply to different content types:

| Type         | Description                                                                     |
| :----------- | :------------------------------------------------------------------------------ |
| Email        | Triggers based on labeled inbound emails, e.g. “Out-of-office”, “Counter-offer” |
| Note         | Triggers when a note is added, either manually or via API                       |
| General rule | Provides overarching behavioral guidance                                        |
| Knowledge    | Stores reusable sales knowledge for recurring questions                         |

## Best practices

* **Start with the default rules**\
  FirstQuadrant comes with pre-set rules that work well for most users. Customize them only once you're familiar with how the AI behaves.
* **Think assistant, not computer**\
  You’re not setting up workflows—you’re training a reasoning assistant.
* **Segment by contact types**\
  You can assign different rules for different customer segments like “buyers” vs “sellers.”
* **Iterate gradually**\
  Add or tweak rules only when the AI’s behavior doesn’t match your expectations.

## Managing rules

All existing rules are displayed in a centralized list under the Fine-tuning section. From here, you can:

* View all labels and types
* See at-a-glance instructions
* Edit or update rules as needed

By thoughtfully applying fine-tuning rules, you turn FirstQuadrant into an intelligent sales assistant that truly understands how your team works.


# Language support
Source: https://docs.firstquadrant.ai/product-manual/fine-tuning/langauge-support

FirstQuadrant supports communication in any language, making it suitable for global sales teams. While the platform interface is only available in English, the AI can read, understand, and respond in any known language. This article explains how to configure multilingual support by setting up fine-tuning rules that guide the AI on when and how to respond in specific languages and grammar styles.

## Platform language vs. conversation language

* **User interface (UI):** All menus, buttons, settings, and general platform navigation are in English. Currently, the FirstQuadrant UI does not support other interface languages.
* **AI communication:** FirstQuadrant’s AI can understand messages in any known language and respond fluently in that same language, including following grammar, tone, and cultural norms specific to a region.

***

## How to configure language support

To enable language-specific replies from the AI, you need to create a **fine-tuning rule**.

### Step 1: Create a new general rule

1. Navigate to the **Fine-Tuning Settings**
2. Click **New Rule**.
3. Select **General Rule** as the type of fine-tuning.
4. Define the audience: You can apply the rule to **all contacts**, or limit it to a specific **segment**

### Step 2: Write the instruction

The instruction should specify:

* When to switch to the target language
* Which grammar rules to follow (if applicable)

**Examples:**

* “If a contact reaches out in German, reply back in German using Swiss grammar conventions.”
* “Respond in Spanish when the incoming message is in Spanish. Use neutral Latin American phrasing.”
* “Always reply in Japanese if the contact is located in Japan.”
* “Always reply in Italian, no exceptions."

The AI will automatically detect the language of the incoming message and apply the rule accordingly.

***

## Additional notes

* You can be as **granular or broad** as needed. Whether it’s distinguishing between Swiss and German variants of German, or using Canadian French vs. European French, the underlying AI can handle it with precision.
* These rules are **guidelines**, not rigid if-statements. The AI will use its reasoning to apply them where appropriate, especially when dealing with multilingual contacts or edge cases.

***


# Memory
Source: https://docs.firstquadrant.ai/product-manual/fine-tuning/memory

Memory allows FirstQuadrant to retain useful long-term context across conversations, helping it become smarter and more personalized over time.

The **Memory** feature allows FirstQuadrant to retain useful long-term context across conversations. It helps the AI become smarter and more personalized over time by learning from your past interactions, writing style preferences, company knowledge, and recurring patterns.

Memory is persistent and can be updated manually to ensure FirstQuadrant remembers important details such as how you write your emails, how you typically handle objections, or how your product should be described, and apply this information automatically in future replies.

## How Memory is updated

FirstQuadrant automatically reviews your conversations and decides whether any new information should be saved, removed, or refined. This process ensures only meaningful, generalizable, and consistent information is retained and happens in the background.

## Managing your Memory

You can view and edit your memory through Fine-tunings:

1. Navigate to **Fine-tuning**
2. Click on **Memory** on the top right
3. Review the current memory
4. Edit memory and delete outdated information as needed


# App import
Source: https://docs.firstquadrant.ai/product-manual/imports/app-import

This article explains how to import contacts into FirstQuadrant using connected apps. It covers the three types of integrations—direct, Zapier-powered, and guide-based—and provides step-by-step instructions for setting up each. Use this guide to streamline contact imports from sales, marketing, and scheduling tools.

## Overview

FirstQuadrant allows you to import contacts through a wide range of connected apps. These integrations simplify how you bring data from external tools into your pipeline—without needing to export and reformat files manually.

To get started, navigate to the **Imports** section in the sidebar and click **New import** in the top right. From the dropdown, select **Apps**. This takes you to the App Integrations page, where you’ll see a curated list of tools that can be connected to FirstQuadrant.

## Types of integrations

There are three types of app integrations supported in FirstQuadrant:

### Direct integrations

These are native integrations that allow you to import contacts directly from a tool into FirstQuadrant without needing a third-party middleware.

**Examples include:**

* **Zapier**: A platform that enables workflow automation across 7,000+ tools.
* **Vector**: Imports leads based on visitor intent data collected by Vector.
* **Cal.com**: Add contacts who book meetings from Cal.com.

**To use a direct integration:**

1. Click **Install** on the app.
2. Follow the configuration steps.
3. Once set up, you’ll be redirected to the import settings for that integration.

### Zapier-powered integrations

Many apps are supported indirectly via Zapier. These apps don’t integrate natively with FirstQuadrant, but can be connected using Zaps.

**Examples include:**

* Mailchimp
* Shopify
* Airtable
* Calendly
* Notion

**To connect via Zapier:**

1. Install Zapier from the App page.
2. Create a Zap with a supported trigger (e.g. “new subscriber”).
3. Add a FirstQuadrant action (import contact).
4. Use the webhook URL provided by FirstQuadrant in your Zap configuration.
5. Once configured, contact imports will be triggered automatically.

> **Tip:** You’ll find instructions for each integration by selecting the app and following the steps shown in the right panel.

### Guide-based or indirect connections

Some apps (e.g. email or calendar platforms) don’t offer direct integrations or Zapier support. In these cases, FirstQuadrant provides setup instructions.

**Examples include:**

* Exporting data to CSV and uploading it to FirstQuadrant.
* Connecting your email or calendar account for syncing.

These methods are simple and typically don’t require technical setup.

## After installing an app

Once you complete an app setup (e.g. Zapier), you will be redirected to the **Import settings** screen. This is where you can:

* Configure qualifying questions
* Apply qualification rules (e.g. “email is verified” or “company website is live”)
* Exclude existing contacts from being re-imported
* Choose whether to import contacts as **active** or **inactive**

> **Info:** For a detailed guide on configuring import settings and qualification rules, refer to our [Import settings article](/product-manual/imports/import-settings).


# CSV uploads
Source: https://docs.firstquadrant.ai/product-manual/imports/csv-uploads

Learn how to upload contacts via CSV in FirstQuadrant. This article covers how to prepare your file, map fields, handle errors, and use advanced options like note imports to inform AI-driven outreach.

## How to upload contacts using a CSV file

To import contacts in bulk, go to the **[Imports](/product-manual/imports/imports-overview)** tab in the left-hand navigation menu and click **New import** in the top-right corner. From the dropdown, select **Upload**.

You’ll be directed to the **Import settings** page. From here:

### 1. Download the example CSV

Before uploading your file, download the provided **example CSV** template via the link in the file upload section. If the file doesn’t download, make sure your browser allows file downloads.

> **Info:** If your CSV file does not match the structure of the example, the import will fail.

***

## CSV format requirements

Your CSV can include as many columns as you'd like, and FirstQuadrant allows you to map these columns to a wide range of available contact and company properties.

> **Important:** The only required field is a valid **email address**. Without it, a row will not be processed.

If you're unsure how to structure your data, you can download the **example CSV** provided in the import interface. This example includes commonly used fields like name, email, LinkedIn handle, company name, and company website, but you are not limited to these.

Some of the additional fields you can map include:

* Job title, seniority
* Social handles (LinkedIn, X, Instagram, GitHub, etc.)
* Custom notes (which appear in conversation history)
* Location, timezone
* Company-specific fields like legal name, subtitle, social handles, and Apollo.io IDs

The more fields you map, the better FirstQuadrant can personalize outreach and enrich contact and company data.

> **Important:** The email column **must** contain valid email addresses. If any row contains an invalid value (e.g., a name or other non-email string in the email field), the upload will result in an error.

***

## Uploading the file

Once your CSV is formatted correctly:

1. Click **Upload file** in the import settings.
2. Select your CSV file.
3. A **column mapping modal** will appear, where you must map your file’s columns to the expected properties (e.g., Email → Email, Name → Full Name, etc.).
4. Ensure each column is mapped correctly using the dropdowns. You can clear a mapping if it’s incorrect.
5. Click **Upload \[x] rows** to complete the import.

> **Info:** The mapping menu supports many contact and company-level fields including social handles (e.g., LinkedIn, X, Instagram), job title, seniority, legal name, location, timezone, and even Apollo.io IDs. The more fields you map, the more context FirstQuadrant has for enrichment and personalization.

> **Tip:** If you map a "Note" column, FirstQuadrant will automatically create a note in the contact's [conversation history](/product-manual/contact-view/conversation-history). This note will be used by FirstQuadrant's AI to inform its next-step recommendations and message generation. You can choose whether these notes appear as collapsed event snippets or full notes in the [import settings](/product-manual/imports/import-settings#display-note-as-event-or-note).

***

## Common errors and troubleshooting

If there’s an issue with your upload:

* You’ll see a toast notification in the bottom-right corner explaining what went wrong.
* Most common issues include:
  * Email field is missing or contains invalid data
  * Incorrect column structure
  * Extra unexpected columns
  * Empty rows or broken formatting

Before retrying the upload, double-check the formatting and make sure the CSV only contains the expected headers and valid values.

***

## What happens next?

After uploading, the contacts will appear in your **Imports** list with status **Draft**. At this point, you can continue configuring your import (e.g., qualification rules, activation status, etc.).

> **Info:** The rest of the import settings (such as qualification rules and activation state) are covered in the [import settings article](/product-manual/imports/import-settings).


# Import detailed view
Source: https://docs.firstquadrant.ai/product-manual/imports/import-detailed-view

Learn how to navigate and use the import detailed view to track qualification statuses, understand AI decisions, and manually override results. This guide covers contact status types, qualification logic, editing criteria, and reading the context panel.

## Overview

The import detailed view allows you to inspect all contacts that belong to a specific import. You can access it from the **[Imports overview](/product-manual/imports/imports-overview)** by clicking on any import—whether it's in **Draft**, **Running**, or **Completed** status.

Once opened, the detailed view shows a list of all contacts in the import and their current status in the qualification pipeline. This view helps you monitor the outcome of the qualification rules you've configured and gives you control to make manual adjustments if needed.

## Contact statuses explained

Every contact in an import can be in one of three states:

* **Scheduled**: Contact has been imported but not yet processed or qualified.
* **Qualified**: Contact meets the criteria set in the qualification rules.
* **Unqualified**: Contact does not meet one or more of the qualification conditions.

## Qualification logic

Qualification is driven by the **qualification** **rules and questions** defined in the import settings. FirstQuadrant evaluates each contact step-by-step against these questions.

* **Early stopping**: The qualification process stops as soon as a disqualifying answer is found. To conserve credits, any remaining questions are skipped.
* **AI rationale**: On the right-hand side context panel, you’ll find an explanation of the final qualification decision. This includes:
  * A checklist summary of all qualification criteria.
  * A breakdown of each answered question.
  * Tooltips (hover over the “?” icons) that explain how the AI reached its conclusions.

## Manual override

You can override FirstQuadrant’s qualification decision manually:

* Use the toggle switch next to a contact's status to mark them as **Qualified** or **Unqualified**.
* This can be helpful if you know a contact should be included or excluded based on external knowledge not captured by the AI.

## Editing qualification criteria

To change the logic used for qualification:

1. Click the **Edit import** button in the top right corner.
2. This brings you back to the import setting view, where you can update your qualification questions and logic.
3. Any changes will affect newly processed contacts or require reprocessing of existing ones.

## Context panel

The context panel on the right shows a brief snapshot of the contact and their company, including:

* Name, job title, and company
* Location
* Links to their LinkedIn, company website, or other social media
* Year founded and other company metadata (if available)

> **Info**: This information is limited for contacts who are still in the *Scheduled* state, as full enrichment occurs after qualification.


# Import settings
Source: https://docs.firstquadrant.ai/product-manual/imports/import-settings

The import settings page in FirstQuadrant allows users to configure how new contacts are added to the platform—whether via webhooks, apps, or CSV files. It centralizes all import setup options including naming, qualification filters, enrichment rules, and scheduling. This page is key to ensuring you only import high-quality, relevant contacts tailored to your sales workflow.

## Accessing the import settings page

You can access the Import Settings page in two ways:

* When creating a new import, you are automatically taken to this page.
* If you are revisiting an existing import, click on **Edit import** from the top right corner of the import detail view.

***

## Section 1: Import source (top block)

The first block at the top of the page will vary depending on how you chose to import your contacts:

* **Webhook imports**: Displays a unique Webhook URL and shows a sample payload of how contact data should be structured in JSON format.
* **App imports**: Displays setup instructions specific to the connected app (e.g. Zapier).
* **CSV file imports**: Displays the uploaded CSV files, with an option to add more.

No matter the source, the remaining configuration sections on the page are consistent.

Info: There are separate helpdesk articles available for each of the three import types—Webhook, App, and CSV—which explain their specific setup processes in detail.

***

## Section 2: Naming your import

Every import should have a clear and descriptive name. This helps identify imports later when running campaigns, nurturing flows, or audits. Click into the **Name** field and update it with a recognizable title, such as “Inbound Webhook – Q3 Leads” or “CSV Import – June Newsletter.”

***

## Section 3: Qualification questions

Qualification questions allow you to define specific criteria that contacts or companies must meet before they are officially imported into FirstQuadrant. This is a critical filtering mechanism to ensure only relevant, high-quality records are added to your workspace.

When you upload a list or connect a source (CSV, webhook, or app), the contacts are staged but not yet fully imported. Qualification questions act as a gating layer: FirstQuadrant evaluates each staged contact against your specified criteria, and only those who pass all questions are included in the final import.

These questions are always binary (yes/no) and can target either the company or the contact. They are especially useful for narrowing your target audience to fit your ICP (ideal customer profile). For example:

* **Company-level questions** might ask: *Is the company a B2B SaaS?*, *Is the company SOC 2 compliant?*, or *Does the company have over 50 employees?*
* **Contact-level questions** might ask: *Is this a senior-level decision maker?*, or *Is the contact based in Europe?*

To create qualification questions:

* Click **Add question** to open the builder.
* Choose whether the question applies to a **contact** or a **company**.
* Write your yes/no question.
* Choose the source of the answer:
  * **Perplexity** (default): Uses external AI search to look up the answer.
  * **Internal data**: Pulls from FirstQuadrant's enrichment data (best used when importing known records).
* Decide whether a **yes** or **no** qualifies the record.

You can also in the advanced section:

* Choose to qualify records with **unknown** answers (enabled by default).
* Provide additional context or explanation for the question using the description field.

All contacts must pass **every** qualification question you set. If a contact fails even one, they will not be imported.

**Tip**: You can combine multiple unrelated questions for more refined control over your imports.

***

## Section 4: Qualifying rules

Qualifying rules are additional system-level checks applied *after* a contact has passed all qualification questions. These rules serve as automated filters that help ensure the validity and integrity of your imported data before final import.

You can enable or disable the following rule-based filters:

* **Company website is up**: This rule checks whether the company's domain is live and reachable. If the domain is down or does not resolve, the contact will be disqualified. This helps filter out inactive or defunct companies.
* **Email address is verified**: Uses FirstQuadrant’s built-in email verification service to determine whether the email is likely deliverable. If the email fails verification, the contact is disqualified. This reduces the chances of bouncebacks in outbound campaigns.
* **Professional email is available**: Ensures that contacts use work-related email domains (e.g. [name@company.com](mailto:name@company.com)) and filters out personal domains like Gmail, Yahoo, and Outlook. This is especially useful if you’re focused on B2B outreach.
* **Exclude existing contacts** *(enabled by default)*: If turned on, FirstQuadrant checks whether a contact already exists in your workspace. If yes, they will not be added to this import.

  If this option is turned off, existing contacts will still be included in the current import group. This is useful when you're importing to segment for a specific campaign or initiative. Note that contacts are never duplicated even if they belong to multiple imports.

**Note**: These rules are only evaluated *after* contacts have passed the qualification questions. If a contact is disqualified by a qualification question, these rules are not applied at all.

***

## Section 5: Run AI reasoning

Once contacts pass all qualification checks and rules, you can control whether FirstQuadrant runs AI reasoning on the imported contacts by toggling the **"Run AI reasoning"** option:

* **When enabled**: FirstQuadrant will automatically run AI reasoning on each imported contact, analyzing their profile, company, and context to generate personalized insights, suggested actions, and outreach strategies. This comprehensive AI reasoning consumes **3 credits per contact**.
* **When disabled**: Contacts are imported without AI reasoning. They will be added to your workspace but won't have AI-generated insights, personalized messaging, or suggested next steps until something triggers the reasoning.

**Important credit considerations:**

* Running AI reasoning consumes 3 credits per contact from your workspace allowance
* For large imports (e.g., 1,000+ contacts), consider your available credit balance
* You can always run AI reasoning later on-demand if you choose to import without reasoning

### Guidelines for configuration

Enable **"Run AI reasoning"** if:

* You need immediate AI insights and personalized messaging for these contacts
* You're planning to engage with these contacts soon or they have a conversation history you want to continue
* You have sufficient credits for the import size
* You want the AI to analyze and prioritize these contacts

Disable **"Run AI reasoning"** if:

* You're importing contacts to add to a campaign
* These are cold leads you'll nurture over time
* You prefer to manually select which contacts to process later
* You're importing for data storage rather than immediate engagement

***

## Section 6: Notes (optional)

When importing contacts, you can optionally attach a note that provides additional context for FirstQuadrant's AI to evaluate during its reasoning process.

Here's how it works:

* A note is added **automatically to the end of the conversation history** for each contact in the import.
* When **"Run AI reasoning"** is enabled, that note becomes part of what the AI reviews when determining the contact's status, urgency, and suggested actions.
* These notes can include:
  * Descriptive context about how or why the contact was imported (e.g. "Imported via Zapier from lead gen form")
  * Internal instructions for FirstQuadrant (e.g. "Follow up in 2 weeks with product demo link")
  * Relationship info or meeting history (e.g. "Met at Web Summit 2024")

**Important**: Notes are not just informational. When AI reasoning is enabled, FirstQuadrant uses them as active signals when evaluating next best actions. Even subtle instructions like "warm intro" or "follow-up post-trial" can significantly shape the suggested outreach strategy.

**Note**: If you've disabled "Run AI reasoning" during import, these notes will still be attached to the contacts but won't be analyzed by the AI until you manually trigger reasoning later.

### Display note as Event or Note

When you add a note to your import, you can choose how it appears in the conversation history of each contact by configuring the **"Display note as..."** setting. This setting becomes available when a note is provided.

**Two display options:**

* **Event**: The note is displayed as a collapsed event snippet in the conversation history. Only the first line of the note is shown initially, making it ideal for brief status updates or milestone markers. Users can click to expand and see the full note content.
* **Note**: The note is displayed in its full form as a traditional note in the conversation history. This is the default behavior and is best for detailed context or instructions that should be immediately visible.

**When to use Event display:**

Choose **Event** when your note represents:

* A point-in-time occurrence (e.g., "Contact attended webinar on product features")
* A status change or milestone (e.g., "Trial period started")
* Brief updates that don't require immediate full visibility (e.g., "Downloaded pricing guide")
* Bulk imports where you want to minimize visual clutter in the conversation history

**When to use Note display:**

Choose **Note** when your note contains:

* Detailed context or background information
* Specific instructions for follow-up
* Multi-line content that needs to be fully visible
* Important information that the AI should prominently consider

***

## Section 7: Scheduling the import

You can choose when and how the contacts should be imported:

* **Import all rows immediately**: All qualified contacts are imported at once.
* **Import on a recurring schedule**: Specify a number of contacts to import periodically (e.g. 100 contacts per month).

Use case:

* When importing from a large prospecting list (e.g. 100,000 contacts).
* To conserve credits and stagger outreach.
* To defer engagement or stagger workload.

***


# Imports overview
Source: https://docs.firstquadrant.ai/product-manual/imports/imports-overview

Learn how to use imports in FirstQuadrant to bulk add contacts via CSV upload, API, or app integrations. This article explains the import overview, available import methods, status states, and why importing is essential for enabling AI-driven workflows.

### What are imports?

In FirstQuadrant, **imports** are the primary way to add contacts in bulk to your workspace. While individual contacts can be added manually, imports allow for automated and large-scale contact ingestion—critical for enabling FirstQuadrant’s AI to run reasoning and engage with the right leads.

FirstQuadrant only runs AI reasoning on emails for contacts that have been explicitly added to your workspace. Without importing contacts, the platform cannot run enrichment, email syncing, or any other automations tied to contact data.

***

### Navigating to the import overview

To access your import overview:

1. Click **Imports** from the sidebar on the lower left, right above **Settings**.
2. This brings you to the **Import Overview** page, where all active, completed, and draft imports are listed.

Each row in the list shows:

* **Name** of the import
* **Status**: Draft, Running, or Completed

***

### Import statuses explained

An import can be in one of three states:

* **Draft**: The import setup has started but has not yet been run. No contacts have been imported.
* **Running**: The import is in progress. This status appears in two scenarios:
  * The import is set up as **recurring** (e.g. CSV uploads set to run periodically).
  * The import source is **continuous** (e.g. Webhooks, API, or connected third-party apps continuously feeding new data).
* **Completed**: The import has fully run and all intended contacts were successfully added.

***

### Import methods

When creating a new import (via the **New import** button on the top right), you can choose from four options:

1. **Upload** – Upload a CSV file with your contact list.
2. **Webhooks** – Import contacts programmatically using the FirstQuadrant API.
3. **Apps** – Use integrations (e.g. Zapier) to import contacts from 7000+ third-party apps.

Each method serves different workflows and levels of automation. Individual guides for each are provided in separate helpdesk articles.

***

### Why imports matter

> **Info**: FirstQuadrant’s AI reasoning, email syncing, enrichment, and task generation only apply to contacts that have been explicitly imported into your workspace. Simply viewing or mentioning a contact elsewhere won’t activate these features.

By properly setting up imports, you ensure that:

* Your AI workflows have high-quality data to act on.
* Your outreach, nurturing, and fine-tuning campaigns target the right audiences.
* You don’t waste AI credits or attention on irrelevant contacts.

***


# Webhooks import
Source: https://docs.firstquadrant.ai/product-manual/imports/webhooks

This article explains how to use webhook-based imports to send real-time contact and company data from external tools—like CRMs, signup forms, or internal systems—directly into FirstQuadrant. It covers how to locate your unique webhook URL, the expected data format, field-level documentation, response handling, and integration best practices. You’ll also find examples for using webhooks via Zapier or custom applications. This is the most flexible way to programmatically sync high-quality data into your workspace and trigger AI workflows instantly. 

## Overview

FirstQuadrant supports **webhook-based imports** as a powerful way to send contact and company data directly into your workspace in real time. This is particularly useful for integrating external systems such as CRMs, marketing platforms, signup forms, or internal tools with FirstQuadrant.

Webhooks allow you to push data into FirstQuadrant automatically whenever a new contact is created or updated externally.

## Where to find your webhook

Navigate to the **Imports** section in your workspace. From there:

* Click **new import**
* You will be provided with a **webhook URL** specific to that import.
* This URL includes a secure hash and should be kept private.

FirstQuadrant provides webhooks as a powerful way to automatically import contacts and companies from external systems. Webhooks allow you to send real-time data to FirstQuadrant whenever new contacts are created in your CRM, marketing automation platform, or any other system.

## Webhook URL format

Your webhook URL will follow this format:

```
https://api.us.firstquadrant.ai/v5/imports/{importId}/trigger/{hash}
```

Where:

* `{importId}` is your unique import identifier
* `{hash}` is a secure hash that validates webhook requests

## Making webhook requests

Send a `POST` request to your webhook URL with a JSON body containing contact and company data. The minimum required structure is:

```json  theme={null}
{
  "contact": {
    "email": "jane.doe@example.com"
  }
}
```

### Complete data structure

You can provide comprehensive contact and company information using the following schema:

```json  theme={null}
{
  "contact": {
    "email": "jane.doe@example.com",
    "name": "Jane Doe",
    "nickname": "Jane",
    "bio": "Senior Sales Manager at Acme Corp",
    "avatar": "https://example.com/avatar.jpg",
    "website": "https://janedoe.com",
    "domain": "janedoe.com",
    "location": "San Francisco, CA",
    "timeZone": "America/Los_Angeles",
    "facebookHandle": "janedoe",
    "gitHubHandle": "janedoe",
    "instagramHandle": "janedoe",
    "linkedInHandle": "jane-doe",
    "xHandle": "janedoe",
    "externalIdApollo": "apollo_123",
    "note": "Met at conference, interested in enterprise plan"
  },
  "employment": {
    "title": "Senior Sales Manager",
    "seniority": "SENIOR",
    "history": [
      {
        "current": true,
        "start": "2022-01",
        "organization": "Acme Corporation",
        "title": "Senior Sales Manager"
      },
      {
        "current": false,
        "start": "2020-03",
        "end": "2021-12",
        "organization": "Previous Company",
        "title": "Sales Manager"
      }
    ]
  },
  "company": {
    "name": "Acme Corporation",
    "nickname": "Acme",
    "bio": "Leading provider of innovative solutions",
    "subtitle": "Innovation at its finest",
    "avatar": "https://example.com/logo.png",
    "website": "https://acme.com",
    "domain": "acme.com",
    "location": "San Francisco, CA",
    "timeZone": "America/Los_Angeles",
    "facebookHandle": "acmecorp",
    "gitHubHandle": "acmecorp",
    "instagramHandle": "acmecorp",
    "linkedInHandle": "acme-corporation",
    "xHandle": "acmecorp",
    "annualRevenue": "10000000",
    "employeesCount": 250,
    "foundedYear": 2015,
    "fundingStage": "Series B",
    "fundingTotal": "25000000",
    "retailLocationsCount": 5,
    "ticker": "ACME",
    "industries": ["Technology", "SaaS"],
    "languages": ["English", "Spanish"],
    "stack": ["React", "Node.js", "PostgreSQL"],
    "tags": ["enterprise", "b2b"],
    "externalIdApollo": "apollo_company_456"
  }
}
```

### Field descriptions

#### Contact fields

* **email** (string, nullable): Primary email address
* **name** (string, nullable): Full name of the contact
* **nickname** (string, nullable): Common or preferred name
* **bio** (string, nullable): Description or bio from social media
* **avatar** (string, nullable): URL to profile picture
* **website** (string, nullable): Personal website URL
* **domain** (string, nullable): Domain of personal website
* **location** (string, nullable): Geographic location
* **timeZone** (string, nullable): Time zone (e.g., "America/Los\_Angeles")
* **social handles**: Facebook, GitHub, Instagram, LinkedIn, X (Twitter) handles
* **externalIdApollo** (string, nullable): External ID from Apollo.io
* **note** (string, nullable): Additional context or notes

#### Employment fields

* **title** (string, nullable): Job title
* **seniority** (string, nullable): Seniority level (JUNIOR, MID, SENIOR, EXECUTIVE)
* **history** (array): Work history with start/end dates, organization, and title

#### Company fields

* **name** (string, nullable): Legal company name
* **nickname** (string, nullable): Common or brand name
* **bio** (string, nullable): Company description
* **subtitle** (string, nullable): Short company description
* **avatar** (string, nullable): Company logo URL
* **website** (string, nullable): Company website URL
* **domain** (string, nullable): Company domain
* **location** (string, nullable): Company headquarters location
* **timeZone** (string, nullable): Company time zone
* **social handles**: Company social media handles
* **financial data**: Revenue, employee count, funding information
* **industries** (array): Industry categories
* **languages** (array): Languages supported
* **stack** (array): Technology stack
* **tags** (array): Custom tags
* **externalIdApollo** (string, nullable): External ID from Apollo.io

## Response format

Successful webhook requests return a JSON response with the created row data:

```json  theme={null}
{
  "id": "row_123456789",
  "object": "row",
  "status": "PENDING",
  "createdAt": "2024-01-15T10:30:00Z",
  "updatedAt": "2024-01-15T10:30:00Z"
}
```

## Error handling

Webhook requests may return the following HTTP status codes:

* **200**: Success - Contact imported successfully
* **400**: Bad Request - Invalid data format
* **404**: Not Found - Invalid webhook URL or hash
* **429**: Rate Limited - Too many requests
* **500**: Internal Server Error - Server error

## Best practices

### Data quality

* Always provide an email address when possible
* Use consistent formatting for names and company information
* Include relevant social media handles for better enrichment
* Add notes to provide context about the contact

### Rate limiting

* Implement exponential backoff for failed requests
* Don't send duplicate data for the same contact
* Batch multiple contacts when possible

### Security

* Keep your webhook URL and hash secure
* Use HTTPS for all webhook requests
* Validate data before sending to FirstQuadrant

### Monitoring

* Monitor webhook response codes
* Set up alerts for failed webhook requests
* Track the number of contacts imported via webhooks

## Integration examples

### Zapier integration

1. Create a new Zap with your trigger app
2. Add FirstQuadrant as an action
3. Use the webhook URL as the endpoint
4. Map your trigger data to the webhook payload

### Custom application

```javascript  theme={null}
const webhookUrl = "https://api.us.firstquadrant.ai/v5/imports/imp_123/trigger/fqw_abc123";

const contactData = {
  contact: {
    email: "new.contact@example.com",
    name: "John Smith",
    note: "Imported from CRM system",
  },
  company: {
    name: "Example Corp",
    website: "https://example.com",
  },
};

fetch(webhookUrl, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify(contactData),
})
  .then((response) => response.json())
  .then((data) => console.log("Contact imported:", data))
  .catch((error) => console.error("Error:", error));
```

## Additional notes

* Notes added via webhook are treated the same way as manual notes.
* These notes are run through AI reasoning to guide next-step decisions in conversation workflows.
* To fine-tune how notes are handled, visit **[Fine-Tune Settings](/product-manual/fine-tuning/fine-tuning-overview)** in your workspace.


# Website visitor identification via Vector
Source: https://docs.firstquadrant.ai/product-manual/imports/website-visitors

This article explains how to import contacts into FirstQuadrant using website visitor identification with Vector.co It provides step-by-step instructions on setting up the integration, naming your import, applying qualification filters, and adding optional context. It also highlights why Vector is the recommended provider due to its accuracy and generous free plan.

## Steps to import contacts via website visitor identification

### 1. Navigate to import contacts

* Go to [Contacts](/product-manual/records/records-overview) > [Import Contacts](/product-manual/imports/imports-overview) > [Apps](/product-manual/imports/app-import)

### 2. Set up website visitor identification

* Choose either Vector or RB2B to set up website visitor identification
* Follow the setup instructions provided by your chosen provider

<Note>
  We recommend using **Vector** for visitor identification because of its superior accuracy, ease of use, and generous
  free plan.
</Note>

### 3. Name your import

* Assign a recognizable name to the import for easier tracking and management

### 4. Optionally qualify your contacts

* Before importing, you can apply filters to qualify your contacts based on specific criteria to ensure only relevant leads are added

### 5. Add an optional note

* Include any additional notes or context regarding the imported contacts for internal reference and to instruct FirstQuadrant

Once the setup is complete, FirstQuadrant will automatically track and categorize website visitors, allowing you to engage them effectively through targeted messaging.


# Adding all email accounts for best practice
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/add-all-email-accounts

To maximize FirstQuadrant’s impact, it’s best practice to connect all current and past sales-related email accounts from your organization. This enables the platform to sync historical conversations with leads, provide your team with full context, and improve the AI’s recommendations. When past accounts are added, FirstQuadrant retrieves previous email threads, displays them to current users, and incorporates this context when generating new outreach—ensuring continuity in communication and increasing conversion potential.

[**​**](https://docs.firstquadrant.ai/mailbox-calendar-setup/syncing-past-and-current-email-addresses#why-add-past-email-addresses%3F)**Why add past email accounts?**

By including past sales-related email addresses in your FirstQuadrant workspace, the platform can:

* Sync all past email conversations with leads that past and current sales employees engaged with
* Display these conversations in the platform for current team members
* Enhance AI-driven insights by providing historical context to ongoing lead interactions[**​**](https://docs.firstquadrant.ai/mailbox-calendar-setup/syncing-past-and-current-email-addresses#how-this-improves-ai-recommendations)

## **How this improves AI recommendations**

For example, if an email address previously corresponded with a prospect named “Jasmin,” FirstQuadrant will:

* Automatically sync and retrieve these past email exchanges
* Acknowledge this prior interaction when generating new AI-driven outreach emails
* Ensure continuity in sales conversations

## **Example AI-generated email**

**Subject:** Continuing Our Conversation

> “Hi Jasmin, I know that you have been in contact via email in the past regarding \[specific topic]. I’d love to continue that discussion and explore how we can assist you moving forward. Let’s set up a time to chat!”

By leveraging historical interactions, FirstQuadrant ensures your sales team maintains relationship continuity, builds trust, and increases the chances of converting leads into customers.


# Add FirstQuadrant as a trusted developer in Google Workspace
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/add-as-trusted-developer-google-workspace

This helpdesk document provides a step-by-step guide for Google Workspace super admins on how to designate FirstQuadrant as a trusted third-party app. It walks through the process in the Google Admin console—from locating the API controls to entering the correct OAuth client ID and assigning trusted access. The guide clarifies that this action only allows FirstQuadrant to request access and does not grant any permissions by default.

## Overview

To allow FirstQuadrant to request access to your Google Workspace data (such as Gmail, Calendar, or Contacts), your organization’s Google Workspace super admin must designate FirstQuadrant as a trusted developer. This setup does **not**grant data access—it simply permits FirstQuadrant to initiate access requests in a separate user-controlled flow.

## Prerequisites

### What you need before starting

* Super admin privileges in your Google Workspace domain
* Access to [admin.google.com](https://admin.google.com/)

## Step-by-step instructions

### Step 1: Navigate to API Controls

1. Open [admin.google.com](https://admin.google.com/) and log in as a super admin.
2. From the left sidebar, go to **Security**.
3. Under **Access and data control**, click on **API controls**.

### Step 2: Open third-party app management

1. Under **App access control**, click **Manage third-party app access**.

### Step 3: Add a new app

1. Click **Configure new app**.
2. Choose **OAuth App Name or Client ID**.
3. Paste the following Client ID into the search field:

```
470411331886-vf3vhsd4rr1oje0i6ogvmc5rr71hngnn.apps.googleusercontent.com
```

4. Click **Search**.

### Step 4: Select FirstQuadrant

1. Select **FirstQuadrant** from the search results.
2. Confirm the app type is **Web**.
3. Click **Continue**.

### Step 5: Choose access scope

1. Select **All users in your organization** or choose specific **organizational units**.
2. Click **Continue**.

### Step 6: Assign access level

1. Choose **Trusted** to allow the app to request OAuth scopes.
2. Click **Continue**.

### Step 7: Review and finish

1. Review the app details and access settings.
2. Click **Finish**.

## Important note

### This step does not grant data access

Adding FirstQuadrant as a trusted app only enables it to request access. **It does not grant any access by default.** Users must still authorize data access individually in a separate flow.

## Troubleshooting

### Common issues and resolutions

* If "Configure new app" is not visible, verify that you are logged in as a super admin.
* Ensure the Client ID is pasted correctly without extra spaces or characters.

Once this is done, your users can begin integrating their Google accounts with FirstQuadrant through the app interface.


# Adding generic email addresses
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/adding-generic-email-addresses

This article explains how to add generic inbound email addresses like sales@example.com or enquiry@example.com to FirstQuadrant. It covers two methods—either by manually logging the email as a note or by directly adding the email address to FirstQuadrant. The guide also outlines key limitations, including support only for sales-related emails and the requirement for real (non-alias) email addresses.

Generic email addresses like `sales@example.com` or `enquiry@example.com` can be added to FirstQuadrant in two ways:

## Option 1: Manually adding contacts with inbound email as a note

1. Manually add the contact to FirstQuadrant.
2. Include the inbound email address as a note in the contact entry.
3. FirstQuadrant will then evaluate the next steps based on the information in the note.

## Option 2: Adding the generic email address to FirstQuadrant

1. Add the generic email address to FirstQuadrant.
2. Do not connect it to any team member.
3. Any sales-related inbound emails received at the address will automatically add a contact in FirstQuadrant with a corresponding response.

### Important Notes:

* Only sales-related emails will be added to FirstQuadrant. Other types of emails will not be used for AI reasoning.
* Only real email addresses work at the moment. Email aliases will not function.


# Apps
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/apps

This article explains the Apps integration settings in FirstQuadrant. It covers how to view, install, and manage third-party app integrations including Zapier, Perplexity, Slack Connect, and various outbound sales tools. It also references where to find detailed instructions for importing contacts via these integrations.

## Overview

The **Apps** section under **Settings > Integrations > Apps** in FirstQuadrant allows you to manage all the third-party applications that FirstQuadrant integrates with. These integrations enable you to enrich your workflows, streamline data imports, and automate various parts of your sales execution process.

## Installed apps

At the top of the page, you’ll see a list of apps currently installed and active in your workspace.

## Featured apps

Below the installed apps, you’ll find a list of **featured integrations** that are purpose-built to work well with FirstQuadrant:

## Other apps

This section includes tools that can be connected to FirstQuadrant to help manage various parts of your outbound and other workflows.

## How to use apps for importing contacts

If you're looking to use any of these integrations to import contacts into FirstQuadrant, please refer to the dedicated helpdesk article: **[Importing contacts via apps](/product-manual/imports/app-import)**. It provides detailed step-by-step instructions for each supported integration.


# Calendar accounts 
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/calendar-accounts

Learn how to connect and configure calendar accounts in FirstQuadrant to enable automated meeting detection, pipeline progression, and AI-powered follow-ups.

To allow FirstQuadrant to sync events, trigger automation, and track meeting-based activity in your sales process, you must connect at least one calendar account. This ensures FirstQuadrant can detect when meetings are booked or when they may interfere with scheduled outreach steps—allowing the platform to take appropriate actions like pausing sequences or generating relevant follow-ups.

***

## How to connect a calendar account

1. **Navigate to Settings → Integrations → Calendar accounts.**
2. Click **"Connect calendar"** in the top right corner.
3. Choose your provider from the list:
   * Google Workspace
   * Microsoft Office 365
   * Microsoft Exchange
   * Other (for custom or SMTP calendar sources)
4. Complete the authorization flow—this process is the same as when connecting an email account.

***

## Calendar account settings

Once your calendar account is connected, you can:

* **Assign the calendar to a [team member](/product-manual/workspace-settings/members-workspace-settings)** (this is important for syncing activities correctly).
* **Select which individual calendars within that account** should be used for syncing with FirstQuadrant (toggle ON/OFF).

FirstQuadrant will use these synced calendars to detect events and:

* Pause sequences if a meeting is scheduled with a lead.
* Move [deals](/product-manual/records/records-overview) automatically through [pipelines](/product-manual/workspace-settings/pipeline-workspace-settings) after meetings.
* Trigger follow-up generation after a call.

## Invalid connection badge

When a calendar account's OAuth connection expires or becomes invalid, you'll see an **"Invalid"** badge next to the account in the Calendar accounts list. This indicates that FirstQuadrant can no longer access your calendar due to expired authentication. To resolve this:

1. Navigate to **Settings → Integrations → Calendar accounts**
2. Find the account showing the "Invalid" badge
3. Click on the account and select **Reconnect**
4. Complete the reauthentication process through Nylas
5. The "Invalid" badge will disappear once the connection is successfully restored

Without a valid calendar connection, FirstQuadrant won't be able to sync events or trigger automations based on your calendar activities.

***

## Advanced settings: Suggested imports

You can optionally **override the workspace-wide suggested imports** for this specific calendar account.

Under "Advanced settings," enable "Overwrite workspace setting for this account" and choose one of the following:

* **Suggest importing contacts from sales-related conversations only**
* **Suggest importing all discovered contacts**
* **Disable suggested imports entirely**

> **Info**: For a full explanation of what suggested imports are and how they work across the platform, refer to the separate help desk article about [suggested imports](/product-manual/workspace-settings/suggested-imports).

***


# Connecting email accounts
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/email-accounts

This article explains how to connect and manage email accounts in FirstQuadrant. It walks through provider-specific setup (Google, Microsoft, SMTP), login via Nylas, assigning accounts to team members, and configuring advanced settings such as AI suggestions, daily sending limits, and email warming exclusions. Connecting at least one email account is essential for FirstQuadrant to function.

## Overview

FirstQuadrant requires at least one connected email account to function properly. Without at least one email account connected, the platform cannot execute any outbound communication, sync incoming messages, or surface AI-powered recommendations. It is essential to start by connecting your **primary email account** to ensure seamless performance across all features.

## How to connect an email account

1. Go to **Settings > Integrations > Email accounts**.
2. Click the **Connect email account** button located in the top-right corner.
3. You'll see options to choose your provider:
   * **Google Workspace**
   * **Microsoft Office 365**
   * **Microsoft Exchange**
   * **Other** (for SMTP-based providers)
   * **Zapmail** (used when integrating via Zapmail for outbound emails; there's a separate helpdesk article explaining how to configure this integration step-by-step)

### Info

* If you're using **Google Workspace**, you need to add FirstQuadrant as a trusted app in your Google Admin Console. This is mandatory to authorize access. Check out the [respective helpdesk article](/product-manual/integrations-settings/add-as-trusted-developer-google-workspace) for a step-by-step guide.
* If you're connecting a **Microsoft Office 365 or Exchange** account, the **first connection must be made by a super admin** in your tenant. Once the first account is connected, subsequent ones can be connected without super admin privileges.
* You will then be redirected to sign in via **Nylas.com** — FirstQuadrant's upstream provider for email and calendar sync. This is expected. Simply proceed by signing in and authorizing access.

## Assigning accounts to team members

During setup, you will be prompted to assign the email account to a **[team member](/product-manual/workspace-settings/members-workspace-settings)**. You can connect an **unlimited number of email accounts per team member**, which is especially useful if you plan to scale your outbound efforts using multiple inboxes.

## Advanced settings

Click on any connected email account to access its **Advanced settings**, which allow for granular customization:

### Signature

* Option to **overwrite the default team member signature** for this account. This is helpful when using different inboxes with different branding or tone.

### Minimum wait time

* By default, there is a five-minute wait time between consecutive emails to the same recipient. You can **override this setting per email account** if needed.

### Suggested imports

* FirstQuadrant periodically reviews your conversations and can suggest importing new contacts.
  * You can choose to:
    * Use the workspace-level default
    * Suggest only contacts from **sales-related conversations**
    * Suggest **all discovered contacts**
    * **Disable suggested imports** entirely for this account

> **Info:** For more details on how suggested imports work, see the [dedicated helpdesk article](/product-manual/workspace-settings/suggested-imports).

### Content identifier (for email warming)

* If you're using email warming tools, add the **content identifier** provided by your warming service. This is usually a unique phrase or code embedded in the email body. FirstQuadrant will use this to **ignore warming emails**, preventing them from polluting your contact database and activity lists.

### Daily sending limit

* By default, campaign emails sent from a given inbox are capped at **20 per day**.
* You can override this per account to increase or decrease the sending cap.
* **Note:** This limit applies only to **[campaign emails](/product-manual/campaigns/campaign-overview)**, not to one-to-one replies or conversations.

### Ramp-up duration

* The default ramp-up duration is **35 days**, gradually increasing email volume to the daily cap.
* This helps maintain domain health and deliverability.
* You can override the duration to customize the ramp-up schedule.

### Reply-to address

* Optionally **override the default reply-to address**. This can be used if you want replies to go to a different address than the sending one.

Once your preferences are configured, click **Update email account** to save your changes.

## Managing existing accounts

In the **Email accounts** list view, hover over any connected account to reveal the **three-dot menu**. Available actions include:

* **Reconnect** – reauthenticate the account if syncing fails or token expires
* **Sync now** – manually trigger a data sync
* **Delete** – remove the email account from FirstQuadrant
* **Copy** – copy the connected email address

### Invalid connection badge

When an email account's OAuth connection expires or becomes invalid, you'll see an **"Invalid"** badge next to the account in the list. This indicates that FirstQuadrant can no longer access the email account due to expired authentication. To resolve this:

1. Click on the account showing the "Invalid" badge
2. Select **Reconnect** from the three-dot menu
3. Complete the reauthentication process through Nylas
4. The "Invalid" badge will disappear once the connection is successfully restored

## Nylas

FirstQuadrant uses a secure platform, Nylas, to connect to your email and calendar accounts.

By acting as a trusted integration provider, Nylas allows FirstQuadrant to sync messages and calendar data across popular services like Gmail, Outlook, and others, all without requiring you to share your email credentials directly with us.

This ensures your data remains protected while unlocking powerful productivity features within FirstQuadrant. You can learn more about Nylas and its security standards at [nylas.com](https://nylas.com).


# HubSpot
Source: https://docs.firstquadrant.ai/product-manual/integrations-settings/hubspot

This article explains how to connect and configure HubSpot integration in FirstQuadrant. It covers contact importing, BCC auto-logging for email tracking, two-way pipeline synchronization, and deal syncing between FirstQuadrant and HubSpot. Learn how to import contacts, set up automatic email logging, sync your sales pipelines, and keep deals synchronized across both platforms.

## Overview

The HubSpot integration in FirstQuadrant enables seamless synchronization between FirstQuadrant and HubSpot, providing three powerful features:

1. **BCC Auto-logging** - Automatically log all outgoing emails to HubSpot
2. **Two-way Pipeline & Deal Sync** - Keep your sales pipelines and deals synchronized between both platforms
3. **Contact Import** - Import all your HubSpot contacts into FirstQuadrant with automatic field mapping

To get started, navigate to **Settings > Integrations > Apps** and connect your HubSpot account.

## How to connect HubSpot

1. Go to **Settings > Integrations > Apps** in FirstQuadrant
2. Find **HubSpot** in the available integrations list
3. Click **Connect** to begin the authorization process
4. You'll be redirected to HubSpot to log in and grant permissions
5. Once authorized, you'll be returned to FirstQuadrant with your connection established

After connecting, FirstQuadrant automatically retrieves your HubSpot portal information including your Portal ID and data hosting location, which are used for configuring features like BCC auto-logging.

## BCC auto-logging

BCC auto-logging ensures that all your outbound emails sent through FirstQuadrant are automatically logged in HubSpot, maintaining a complete activity history for your contacts.

### How it works

When enabled, FirstQuadrant automatically adds HubSpot's unique BCC email address to all outgoing emails.

### Configuring BCC auto-logging

1. After connecting HubSpot, go to the HubSpot integration settings
2. Toggle **Enable BCC auto-logging** to turn on this feature
3. The BCC email field will automatically populate with your unique HubSpot BCC address, but you can also manually enter your own BCC email address
4. Click **Save** to apply the settings

Once enabled, every email sent through FirstQuadrant will be automatically logged to the corresponding contact's timeline in HubSpot.

## Pipeline synchronization

FirstQuadrant can automatically create and maintain synchronized pipelines in HubSpot that mirror your FirstQuadrant sales pipelines.

### How it works

* **Automatic pipeline creation**: For each pipeline in FirstQuadrant, a corresponding pipeline is created in HubSpot with the prefix `[FirstQuadrant]`
* **Multiple pipeline support**: If you have multiple pipelines in FirstQuadrant, multiple corresponding pipelines will be created in HubSpot
* **Stage mapping**: All stages from your FirstQuadrant pipeline are mapped to HubSpot, including probability calculations based on stage weights
* **Default stages**: The system automatically adds "Lost" (0% probability) and "Won" (100% probability) stages to complete the pipeline

### Enabling pipeline sync

1. In the HubSpot integration settings, toggle **Enable pipeline synchronization**
2. FirstQuadrant will automatically:
   * Create new pipelines in HubSpot for each of your FirstQuadrant pipelines
   * Map all existing stages with appropriate probabilities
   * Set up tracking for ongoing synchronization
3. Click **Save** to activate the synchronization

## Two-way deal sync

The two-way deal synchronization ensures that your deals remain perfectly synchronized between FirstQuadrant and HubSpot, regardless of where changes are made.

### Features

* **Bidirectional updates**: Changes made in either FirstQuadrant or HubSpot are automatically synced to the other platform
* **Complete deal data sync**: Synchronizes deal name, amount, stage, owner, and close dates
* **Automatic company creation**: When syncing deals, FirstQuadrant automatically creates or links companies based on contact domains
* **Owner mapping**: Intelligently maps deal owners between systems with automatic fallback to default owners when needed
* **Real-time updates**: HubSpot changes are synced without a delay of more than a few seconds

### What gets synced

**From FirstQuadrant to HubSpot:**

* Deal creation, updates, and deletions
* Deal properties (name, amount, stage, close date)
* Deal owner assignments
* Associated companies (created automatically from contact data)

**From HubSpot to FirstQuadrant:**

* Deal stage changes
* Deal property updates
* Deal deletions
* Owner reassignments

### How synchronization works

1. **Initial sync**: When you first enable deal sync, all existing FirstQuadrant deals are pushed to HubSpot
2. **Ongoing sync**:
   * FirstQuadrant changes are pushed to HubSpot in real-time
   * HubSpot changes are received and processed automatically
3. **Conflict resolution**: The most recent change takes precedence in case of conflicts

## Settings and configuration

### Managing your connection

You can view and manage your HubSpot connection settings by:

1. Going to **Settings > Integrations > Apps**
2. Clicking on the HubSpot integration
3. Here you can:
   * View connection status and portal information
   * Enable/disable BCC auto-logging
   * Enable/disable pipeline synchronization
   * View sync status and error logs
   * Disconnect the integration if needed

### Troubleshooting

If you experience issues with the HubSpot integration:

1. **Connection errors**: Try disconnecting and reconnecting your HubSpot account
2. **Sync delays**: Check the error logs in the integration settings for specific issues
3. **Pipeline limits**: HubSpot has limits on the number of pipelines; ensure you haven't reached the maximum
4. **Missing deals**: Verify that deal sync is enabled and check for any error messages in the logs

## Limitations

* **Associations**: Contact and company associations from HubSpot are not directly synced to FirstQuadrant. Updates to associated records in HubSpot won't automatically reflect in FirstQuadrant
* **Custom fields**: Only standard deal fields are synchronized; custom HubSpot fields are not currently supported

## Contact import

FirstQuadrant allows you to import all your HubSpot contacts with just a few clicks, making it easy to bring your existing contact database into FirstQuadrant.

### How it works

The contact import feature creates a one-time import of all your HubSpot contacts into FirstQuadrant. The import automatically maps HubSpot contact fields to FirstQuadrant fields, including:

* Contact name (from firstname and lastname)
* Email address
* Company name
* Job title
* Additional HubSpot properties are preserved in the contact notes

### Importing contacts from HubSpot

1. After connecting HubSpot, go to the HubSpot integration settings
2. In the **Import** section, click **Import contacts**
3. Confirm that you want to create the import
4. FirstQuadrant will create a new import with all your HubSpot contacts
5. You can choose to go to the Imports page where you can:
   * Review the contacts that will be imported
   * Add qualifying questions to filter contacts
   * Configure import settings like deduplication rules
   * Start the import process when ready

### Managing imported contacts

Once you've created a contact import:

* Click **HubSpot contacts** to view and manage the import
* The import will show as pending until you start it
* You can review all contacts before processing
* Existing contacts with matching emails will be connected rather than duplicated
* After processing, imported contacts will be available in your FirstQuadrant contacts list

> **Info:** Contact import is a one-time operation, not a continuous sync. For ongoing synchronization of deals and pipelines, use the pipeline sync feature.


# My account settings
Source: https://docs.firstquadrant.ai/product-manual/my-account-settings

This article explains how to manage your personal settings in FirstQuadrant under the “My account” section. It covers how to update your profile information, switch between workspaces, adjust the app theme, set your time zone, and log out.

FirstQuadrant allows each user to manage their personal account settings under the **My account** section in the left-hand sidebar. This section is designed to help you personalize your experience across workspaces and ensure key profile information is up to date.

## Navigating to My account

To access your account settings:

1. Go to the bottom-left corner of the app and click your name.
2. In the dropdown menu, you'll find the following options:
   * **Workspaces**: Switch between different workspaces you are a member of.
   * **Theme**: Choose between system default, light mode, or dark mode.
   * **Profile**: Jump to your profile settings.
   * **Logout**: Log out of your current session.

## Profile settings

Clicking on **Profile** under **My account** allows you to:

* **Edit your name**
* **Update your email address**
* **Set your time zone** using the dropdown menu

Once changes are made, click **Update profile** to save them.

> **Note:** The time zone you set here affects timestamps throughout FirstQuadrant, such as scheduling and activity logs.


# Notes
Source: https://docs.firstquadrant.ai/product-manual/notes

Add and manage notes throughout your sales process in FirstQuadrant. Notes can include meeting summaries, AI instructions, or personal reminders, and are processed by the AI to guide next steps. Notes can be added manually, during imports, or in response to AI tasks, with customization options available in Fine-Tune Settings.

FirstQuadrant allows users to add notes in multiple places within the conversation history to enhance sales tracking and AI-driven recommendations. Notes can be used for documentation, AI instructions, or personal reference, ensuring seamless sales process management.

## Adding notes

Users can add notes in several ways:

* **When adding a contact manually**—Notes can be included while creating a new contact to ensure all relevant details are stored from the beginning
* **During bulk imports**—Users can add bulk notes to all contacts being imported, ensuring consistent information across multiple leads. Notes can be displayed as collapsed events or full notes in the conversation history (see [Import Settings](/product-manual/imports/import-settings#display-note-as-event-or-note))
* **Manually at any time**—By clicking on the note icon in the footer bar of a conversation, users can add notes whenever needed
* **In response to a FirstQuadrant task**—Sometimes, FirstQuadrant prompts users to add a note in response to a generated task to improve AI-driven workflows

## Types of notes

Notes in FirstQuadrant can include any type of information, such as:

* **Meeting notes**—Summarize key discussions and follow-ups
* **Instructions for FirstQuadrant's AI**—Guide the AI on how to handle specific contacts or sales scenarios
* **Personal notes**—Store information relevant to a contact or deal that may be useful later

## Impact on sales conversations

Any note added to a conversation is processed by FirstQuadrant's AI to evaluate the next steps in the sales process. Notes enhance the AI's ability to make informed decisions and recommend actions tailored to each lead.

## Customizing note behavior

Users can fine-tune how FirstQuadrant processes specific types of notes by adjusting settings in the Fine-Tune Settings. This allows users to customize how different note types influence AI-driven recommendations and automation workflows.

By leveraging notes effectively, users can ensure better organization, improved AI decision-making, and streamlined sales operations within FirstQuadrant.

## Tasks to add notes

Sometimes, FirstQuadrant prompts users to add a note in response to a generated task to improve AI-driven workflows. These prompts are designed to enhance the AI's understanding of your sales process and improve the accuracy of future recommendations and automated actions. By capturing context and outcomes through these prompted notes, FirstQuadrant can provide more personalized and effective sales automation.

### Answer questions

If FirstQuadrant doesn't know the answer to a question, it will create a task for you to answer it. This includes:

* **Contact information requests**: "What's your phone number?", "What's your email address?"
* **Pricing inquiries**: "How much does it cost?", "What are your rates?"
* **Availability questions**: "Can we meet today?", "When are you available?"
* **Product-specific questions**: "Do you support feature X?", "What integrations do you offer?"
* **When you've already committed to answering**: "I'll check and get back to you", "Let me find out for you"

### Perform actions

When there is a task that FirstQuadrant cannot do, it will create a task for you to complete it. This includes:

* **After you've committed to doing something**: "I'll call them tomorrow", "I'll create a proposal", "I'll send the contract"
* **Personal involvement or collaboration**: Interviews, content collaborations, partnerships, strategic discussions
* **Human-only tasks**:
  * Direct communication: "Call me", "Text me"
  * Legal processes: Contract signing, document review
  * External scheduling: Using third-party scheduling links, "Use my Calendly when feature X launches"
  * Manual processes: Creating custom proposals, setting up integrations

### Request for meeting notes

FirstQuadrant intelligently monitors your calendar events and automatically creates tasks for adding meeting notes. This automation ensures that important meeting outcomes are captured and processed by FirstQuadrant's AI to determine the next steps in your sales process.

**Note:** Meeting notes tasks are only created when there are participants who haven't declined the meeting. If all external participants have declined the calendar invite, FirstQuadrant will not create a meeting notes task, as the meeting is unlikely to occur.


# Nurturing
Source: https://docs.firstquadrant.ai/product-manual/nurturing

Learn how to use FirstQuadrant’s nurturing feature to automatically re-engage dormant contacts and revive old sales conversations. This guide explains how nurturing rules work, how to configure cadence and instructions, and best practices for generating new pipeline from existing relationships.

Nurturing in FirstQuadrant is a powerful feature that uses AI to re-engage dormant contacts and revive old sales conversations. It's a highly efficient way to generate new pipeline and surface new opportunities from people who already know your company—even if they previously said no. These contacts often have a higher likelihood of converting because some level of familiarity and trust is already established.

***

## How nurturing works

By default, FirstQuadrant includes a Nurturing rule that automatically triggers personalized outreach based on your past conversations and a predefined cadence.

### Key settings for a nurturing rule

#### Applies to

* Choose which segment of your contacts the rule should apply to (e.g., all contacts, a specific [view](/product-manual/records/views), campaign, or import)

#### Cadence

* Define the interval after which nurturing should be triggered (e.g., 12 months)
* Select the anchor point for that cadence. The most common anchor is "Last sent" (i.e., the last email sent to that contact)

#### Daily nurturings

* Set a cap on how many nurturing messages are generated per day. This ensures your actions list stays manageable.

#### Instructions

* Provide natural language instructions to guide how the AI should write the reactivation message.

* Example:

  ```
  - Refer to previous emails to build on the conversation
  - Ask how they are doing and request a catch up
  - Ask to meet for a coffee
  ```

* You can also use the instruction field to define who **should or should not** be nurtured. For example:

  ```
  - Do not nurture contacts who explicitly said they are not interested
  - Only nurture contacts with whom I exchanged at least three emails
  - Only nurture contacts I had a direct relationship with
  ```

* These instructions help FirstQuadrant's AI make better decisions about which contacts to prioritize for outreach and which to exclude.

#### Autopilot

* If enabled, FirstQuadrant will automatically generate and send these nurturing messages without requiring manual approval.
* If disabled, nurturing drafts will appear in your **[Actions List](/product-manual/actions)** for review and approval before sending.

***

## What happens once a rule is active

Once your nurturing rule is in place, FirstQuadrant will:

* Continuously evaluate your contacts to identify those that meet the cadence condition (e.g., haven't been emailed in 12+ months)
* Use the instructions and prior conversation history to craft a personalized reactivation message
* Generate a draft of the message or send it automatically (depending on whether Autopilot is turned on)

***

## Best practices

* **Start with a manageable number**: Begin with a daily cap (e.g., 10 nurturings/day) to review and iterate on AI-generated messages
* **Use clear and conversational instructions**: Write your instructions as if you're telling a human assistant what to say
* **Be specific about tone and goals**: If your aim is to request a coffee chat or offer an update on your product, say so in the instruction field
* **Use segmentation wisely**: You can create separate nurturing rules for different audiences (e.g., past demo attendees, churned customers, etc.)
* **Define targeting criteria**: Use the instructions to specify inclusion or exclusion logic, such as avoiding contacts who said "not interested" or only reaching out to high-engagement contacts

***

By reviving warm leads at scale with minimal effort, nurturing is one of the most effective ways to leverage your existing contact base and fill your pipeline without cold outreach.


# Lead scoring 
Source: https://docs.firstquadrant.ai/product-manual/properties/lead-scoring

This article explains how to set up a lead scoring system in FirstQuadrant using custom properties enriched by AI. It covers the difference between demographic and behavioral inputs, how to define and calculate a score, and how to use these scores for segmentation via Views.

A lead scoring system is a method used in sales and marketing to rank prospects based on their likelihood of converting into paying customers. In FirstQuadrant, you can build this scoring system using **[custom properties](/product-manual/properties/properties)**, enriched and maintained by the platform's AI.

## What is lead scoring?

Lead scoring assigns numerical values to contacts based on:

* **Demographic and firmographic data**: e.g. job title, company size, location, industry, revenue
* **Behavioral signals**: e.g. signed up on your site, requested a demo, visited key pages

These scores help you segment leads into categories like hot, warm, or cold — allowing you to prioritize outreach efforts effectively.

## How to create a lead score property

1. Navigate to any contact in FirstQuadrant.
2. In the **[context panel](/product-manual/contact-view/context-panel)**, click **"Add property"** and then select **"Create new property."**
3. In the creation panel:
   * **Property type**: Select `Number`
   * **Property name**: e.g. “Lead score”
4. Toggle on **“Enrich with AI”**
5. Choose **“All contacts”**
6. For **Source**, select **“Enrich from internal data”**

### Define your scoring system

In the **Advanced > Description** field, explain how the score should be calculated. For example:

```
Assign points as follows:
- Signed up on website: 10 points
- Requested demo: 30 points
- Visited pricing page: 10 points
- Y Combinator-backed company: 5 points
- Senior management title: 10 points

Total score should reflect the sum of all applicable points.
```

The AI will then automatically analyze the available internal data to calculate a score accordingly.

> **Important:** For this system to work, the behavioral data (like signups or demo requests) needs to be sent to FirstQuadrant via the API or Webhooks. For example, signing up on your site should trigger a note or event in FirstQuadrant that the AI can read and run reasoning on. Additionally, any demographic or firmographic data used in scoring (such as company size, industry, or job title) may first need to be enriched via separate properties, as well.

## Using lead score for segmentation

Once your lead score property is live and populated, you can use the **[Views](/product-manual/records/views)** feature to filter and segment contacts based on their score — for example:

* `Lead score > 60` → Hot leads
* `Lead score between 30 and 60` → Warm leads
* `Lead score < 30` → Cold leads

This allows you to run targeted campaigns, exports, or nurturing flows.

> See the dedicated helpdesk article on **[Views and segmentation](/product-manual/records/views)** for detailed instructions on setting up filters.


# Properties
Source: https://docs.firstquadrant.ai/product-manual/properties/properties

This article explains how to use properties in FirstQuadrant to structure contact and company data, segment audiences, and enable AI-powered enrichment. It covers the creation of custom properties, enrichment options using Perplexity or internal data, and best practices for managing and testing property-based data workflows.

Properties are one of the most powerful concepts in FirstQuadrant. When used correctly, they allow you to organize your sales data in a structured way, segment your audience with precision, and enable the AI to personalize its behavior—both in how it crafts messages and in how it makes decisions.

## What are properties?

A property is any structured data point attached to either a contact or a company in FirstQuadrant. Examples include job title, company name, headcount, location, industries, or language—but you can also create your own custom properties.

All the information shown in the right-hand context panel (when viewing a contact or company) consists of properties.

Properties are useful in several ways:

* **Segmentation and filtering**: You can use properties to create views and filter your data precisely. Views are covered in a separate helpdesk article which explains how to use them to build targeted segments for campaigns, exports, and personalization.
* **Personalization**: The AI uses these properties when generating emails or making decisions.
* **Enrichment**: Properties can be populated manually or enriched automatically via internal or external data sources.

## Creating a new property

To create a property, navigate to any contact or company view. You’ll see **Add property** appear separately in both the contact section and the company section of the context panel.

You’ll first see a list of default properties. At the bottom, click **New property** to create a custom one.

### Step 1: Select the property type

You can choose from:

* Text
* Checkbox (Boolean)
* Number
* Date
* Single select
* Multi-select

Choose the format that fits the kind of data you want to store.

### Step 2: Name the property

Give your property a clear and specific name. This name is also what the AI will use to understand what the property means—especially important if you plan to enable AI enrichment.

**Example**: `Latest funding round`, `Y Combinator funded`, or `Lost reason`.

Next to the name, you’ll see an icon to control visibility. By default, the property is shown in the context panel. You can toggle it to keep it hidden.

> **Info:** Only properties with a value are shown in the context panel. If a property is empty for a specific contact or company, it won’t appear.

***

## Enriching properties with AI

You can manually fill in property values—or use FirstQuadrant’s AI enrichment. This saves time, scales your workflows, and makes your data far more actionable.

After creating the property, toggle **Enrich with AI**. You'll then choose:

### 1. Scope: All companies or selected views

Although the property is technically attached to all contacts/companies, enrichment can be scoped down to a specific **view**.

This allows you to:

* Conserve AI credits
* Target enrichment only where it makes sense

**Example:** If you already have a view for VC-backed companies, and you create a new property called `Latest funding round`, you may want to enrich this only for VC-backed companies, as others are unlikely to have this data.

### 2. Source: Perplexity vs Internal data

There are two enrichment methods:

#### a) Enrich using Perplexity

This uses Perplexity’s AI search engine to fetch public data from the web.

Ideal for properties like:

* Latest funding round
* Total headcount
* Number of offices
* SOC2 compliance
* Best-selling product

> **Tip:** Before running a large enrichment, test Perplexity manually: Go to [perplexity.ai](https://www.perplexity.ai/). Ask: \_"What was the latest funding round of \[company name]?". \_Try this with 2–3 companies. If results are accurate, you can proceed to enrich in FirstQuadrant.

> **Tip:** To ensure enrichment logic is working as expected before using it broadly, you can alternatively create a small test view with just a few records and apply the enrichment to that view first. This allows you to verify the results and avoid wasting AI credits on a full dataset if something doesn’t work as intended.

#### b) Enrich using internal data

This pulls from:

* Emails
* Notes
* Other properties
* Any synced communication or internal record in FirstQuadrant

It’s best for properties that reflect:

* Past conversations
* Qualitative context
* Historical interactions

**Examples:**

Example 1: Lost reason

Create a property `Lost reason` (as multi- or single-select). When someone declines to work with you, you send a follow-up email asking for the reason. Once the prospect replies, FirstQuadrant can automatically extract the answer and populate the property.

Example 2: Interest in a feature

Let’s say some leads have expressed interest in an upcoming feature. You may have recorded that in meeting notes or emails. You can:

* Create a checkbox property `Interested in Feature A`
* Select enrichment from internal data
* FirstQuadrant will analyze past conversations and auto-tag contacts accordingly

You can then build a view based on this property and use it to run a personalized campaign.

***

## Advanced instructions for enrichment

When creating a property, you can click **Advanced** to open a description box. This allows you to add context or special instructions that the AI should use when enriching the data. This is especially helpful if you're running a complex enrichment that depends on nuanced signals, such as interpreting qualitative feedback from emails or notes.

***


# Records overview
Source: https://docs.firstquadrant.ai/product-manual/records/records-overview

This article provides an overview of the three record types in FirstQuadrant—Deals, Contacts, and Companies. It explains how to navigate, filter, and manually manage records, as well as how these records support but do not replace daily sales execution, which is driven through the Actions list.

## Introduction

In FirstQuadrant, "Records" are the structured directories that help you look up historical data across deals, contacts, and companies. There are three types of records:

* **Deals**
* **Contacts**
* **Companies**

You can access all three from the left-hand side navigation bar. These record views are not designed for day-to-day interaction or pipeline management but rather serve as a reference for past and ongoing interactions. Daily management and progression of opportunities should be done via the **[Actions](/product-manual/actions)** list.

***

## Deal records

### Overview

Deal Records provide a structured table of all deals in your system. For each deal, you can view:

* Name
* Pipeline
* Stage
* Status (Open, Won, Lost, etc.)
* Deal value (displayed in the side panel when selected)

> **Info**: The Deal Records page intentionally does not offer a Kanban-style sales pipeline view. FirstQuadrant's AI automatically progresses deals through the funnel, so users are not expected to manage deal stages manually.

You can customize how much or how little information is displayed in the table using the **Display** button at the top right of the screen.

### Deal details view

Clicking on a deal opens a detailed view that includes:

* All communications with any associated contact(s)
* Company-level metadata
* Deal pipeline and status
* Internal notes and activity logs

This gives you a full audit trail of how the deal originated, developed, and is progressing.

### Filtering and search

You can filter deals using the filter dropdown for attributes like pipeline, stage, status, and value. You can also use the search bar to quickly locate specific deals.

### Manual deal creation

Although deals are typically created automatically by the system, you can also manually create a deal. To do so:

1. Click **"New deal"** on the top right of the Deals page.
2. Select the company, deal name, pipeline, owner, and deal value.
3. Click **"Create deal"** to save.

***

## Contact records

### Overview

The Contact Records page is one of the most critical views in FirstQuadrant. It lists all the contacts in your database, including their:

* Name
* Associated company
* Status and tags

A total contact count is visible at the top of the page.

You can customize which columns are shown or hidden in the table using the **Display** button in the top right corner.

### Filtering and views

You can:

* Filter contacts using system or custom properties
* Access different saved views via the dropdown (e.g. "High frequency contacts," "Website signups," "Replied Feb 2025-now")
* Create new views based on filters
* Access previous imports

> **Info**: Creating and managing views—including how to build custom filters, and understand the strategic purpose of saved views (like segmenting follow-up priorities or isolating high-performing lead sources)—is explained in a [dedicated helpdesk article](/product-manual/records/views).

### Manual contact creation

You can manually add a new contact by clicking **"New contact"** in the top right and entering an email address and, optionally, a note.

### Contact details view

Clicking a contact opens the contact profile page, which includes:

* Contact information (name, email, role, etc.)
* Communication history
* Associated deals and companies

> **Info**: The contact page—including timeline activity, enrichment data, communication threads, and contact-specific settings—is covered in more depth in its [own helpdesk article](/product-manual/contact-view/contact-view).

### Automatic contact deduplication

FirstQuadrant automatically detects and merges duplicate contacts. The continuously looks at recently created contacts to identify potential duplicates based on intelligent patterns. When duplicates are detected with high confidence, the system automatically:

* Merges the contacts into a single record
* Preserves all communication history and activities
* Combines employment and company associations
* Creates an item in the conversation history showing the merge reasoning

This automatic deduplication ensures you never lose track of conversations or have fragmented communication histories across duplicate records. The merge process is intelligent - it only combines contacts when there's strong evidence they represent the same person, preventing accidental merges of different individuals who happen to share similar names.

***

## Company records

### Overview

Company Records show you a directory of all companies in your database. Each row includes:

* Company name
* Website (if available)
* Associated contacts and deals

### Filtering and manual creation

You can filter companies and manually add a new company by clicking **"New company"** in the top right corner. You will be prompted to enter:

* Company name
* Website URL

You can also customize the column display using the **Display** button on the top right.

### Company details view

Clicking into a company record will show:

* Company information (industry, size, funding, etc.)
* All communications with anyone from the company, regardless of deal or contact association

This view helps you track all touchpoints across a company, even when not tied to a specific contact or deal.


# Views
Source: https://docs.firstquadrant.ai/product-manual/records/views

Views in FirstQuadrant are a powerful way to segment your contacts based on shared attributes. They enable sales teams to run more targeted campaigns, apply fine-tuning rules selectively, tailor nurturing flows, or export specific subsets of contacts. This article explains the concept of segmentation, how views work, how to create and use them, and why they're crucial for efficient sales execution.

## Why segmentation matters in sales

Segmentation is the process of dividing your total list of leads or customers into smaller groups (segments) based on shared characteristics—like geography, seniority, behavior, or funding status. This is a foundational concept in sales because different segments often require different messaging, outreach timing, or follow-up strategies.

For example, startup founders on the U.S. East Coast may need different messaging than procurement leads at Fortune 500 companies. Similarly, inbound signups should be treated differently than cold leads. Without segmentation, your sales approach becomes generic and less effective.

***

## What is a view?

In FirstQuadrant, a **view** is a saved list of contacts defined by a set of filters. It is the primary mechanism for segmenting your contacts into relevant subgroups. These filters can be based on default properties (like time zone or company), touchpoint data (like last email received), campaign status, and any custom properties you’ve added.

Segmenting your contacts using views helps ensure that each group receives messaging and actions tailored to their specific characteristics or behaviors. Views are accessible from the top of the Contacts section. You can switch between existing views or create a new one from this dropdown.

> **Tip:** Use views to limit the scope of any automated process in FirstQuadrant. Whether you’re running a sequence, applying a fine-tuning rule, or exporting a list—views give you precision and control.

##

***

## Available filters for views

When creating a view, you can filter contacts using a wide range of properties. These include:

| Filter category           | Properties                                                                                                                           |
| :------------------------ | :----------------------------------------------------------------------------------------------------------------------------------- |
| **Contact properties**    | Name, Nickname, Archived status, Title, Seniority, Location, Time zone, Unsubscribed, Any additional contact-level custom properties |
| **Email and social**      | Email verification, Free email, LinkedIn, GitHub, Instagram, X (Twitter)                                                             |
| **Company properties**    | Company name, Has a deal, Company unsubscribed, Company timezone, Any additional company-level custom properties                     |
| **Campaign and sequence** | Has a campaign, Campaign (specific one), Replied, Sequence status                                                                    |
| **Touchpoints**           | Last touchpoint, Last received, Last sent                                                                                            |
| **Metadata**              | Created, Updated, Object ID                                                                                                          |

These filters can be used individually or in combination to define highly specific and meaningful segments for your sales process.

***

## Creating a view

To create a new view:

1. Navigate to the **Contacts** tab under **Records**.
2. At the top, click on the dropdown next to “All contacts” and select **Create a view** at the bottom.
3. Name the view and optionally add a description.
4. Click **Filters** to define who should appear in the view.
5. Once done, click **Save view**.

You can now access this view at any time from the view dropdown.

> **Note:** Views become especially powerful when combined with **[custom properties](/product-manual/properties/properties)**. These allow you to tailor segments to your specific sales logic (e.g. high-intent leads, pilot users, competitors, etc.).

> **Note:** Views are separate from **Imports**. While both are listed in the same dropdown, imports represent the original source of contacts, whereas views are dynamic and filter-based.

***

## Using views

Once created, views can be used in multiple places across FirstQuadrant:

* **[Campaigns](/product-manual/campaigns/campaign-overview)**: Select a view as your target audience
* **[Fine-tuning rules](/product-manual/fine-tuning/fine-tuning-overview)**: Apply specific behavior only to a view
* **[Nurturing](/product-manual/nurturing)**: Restrict reactivation flows to certain views
* **Exports**: Export only the contacts in a specific view

This makes views an essential tool for scaling personalization and automation in a controlled, segment-based manner.

***

## Editing or deleting a view

To edit or delete a view:

1. Select the view from the dropdown.
2. Click **Edit view** on the top right.
3. You can now update the name, description, filters, or delete the view entirely.

***

## Example: segmenting Y Combinator companies

Let’s say you want to send a campaign only to contacts who are part of Y Combinator-funded companies. Here’s how you’d do it:

1. **Create a custom company property**:
   * Type: Boolean
   * Label: “Y Combinator company” (Yes/No)
   * Enable enrichment with AI to auto-detect if each company is YC-funded.
2. **Create a view**:
   * Name it “Y Combinator companies”
   * Add a filter: `Y Combinator company` = `Yes`
3. **Use the view**:
   * When setting up your campaign, choose this view as the audience.
   * You can also apply custom fine-tuning rules for this segment or exclude them from general nurturing flows.

***


# Related contacts
Source: https://docs.firstquadrant.ai/product-manual/related-contacts

Related contacts are automatically identified connections between contacts in FirstQuadrant based on shared company, communication threads, or calendar events. They help the AI understand organizational context and adjust outreach strategies intelligently across related individuals.

## What are related contacts?

In FirstQuadrant, *related contacts* are individuals who are dynamically associated with a given contact based on their contextual connection. These associations are automatically determined by FirstQuadrant's AI and are shown in the **[context panel](/product-manual/contact-view/context-panel)** of a contact view, under the section labeled "Related contacts."

A contact is considered “related” to another contact if they:

* Work at the same company
* Have been CC’d or mentioned in the same email thread
* Attended the same calendar event
* Show other contextual overlaps in communications or activity

Related contacts cannot currently be added or removed manually.

> **Info:** Related contacts play a critical role in helping FirstQuadrant’s AI understand organizational structure and communication dynamics. They are used internally by the system to improve decision-making and generate more context-aware next steps.

## Why related contacts matter

The concept of related contacts is more than just informational—it enables FirstQuadrant's AI to reason across connected relationships when planning communication steps.

### Example use case:

Imagine you’ve been speaking to Alice at Company X. Alice responds saying now is not the right time and asks you to follow up in September. FirstQuadrant logs this and schedules a reminder for September.

Now, a few weeks later, you get a new inbound message from Bob—another employee at Company X. Bob says your company was brought up in a meeting and he's interested in learning more.

Without the concept of related contacts, FirstQuadrant might treat these conversations independently. It would respond to Bob **and** still send Alice a follow-up in September, unaware that the situation had evolved.

With related contacts in place, however, FirstQuadrant understands that Bob and Alice are connected through the same company and recognizes that Bob's message changes the context of the earlier conversation with Alice. As a result, the platform will likely adjust the scheduled follow-up—possibly skipping it altogether or changing the message—to maintain relevance and avoid redundancy.


# Support options
Source: https://docs.firstquadrant.ai/product-manual/support-options

Overview of the different support channels and help resources available to FirstQuadrant users.

# Support options in FirstQuadrant

FirstQuadrant offers multiple support channels to ensure you can get help quickly, whether you're troubleshooting an issue, looking for guidance, or just exploring how to best use the platform.

## Where to find help

You can access support directly from within the FirstQuadrant platform:

### 1. Help and support menu

In the bottom-left navigation, click on **Help and support** to access:

* **Book a 1:1 call**: Schedule time with our team for personalized assistance.
* **Email support**: Reach us directly via email at [enquiry@firstquadrant.ai](mailto:enquiry@firstquadrant.ai)
* **Phone support**: If enabled, you can get real-time help via phone.
* **Getting started guide**: A quick guide for new users.
* **FirstQuadrant Docs**: Access the full help center documentation, product how-tos, and best practices.

### 2. Ask assistant

Also in the bottom-left navigation, the **Ask assistant** feature lets you interact with our AI assistant. You can ask product-related questions and receive real-time, context-aware answers.

## Slack Connect support (if set up)

If your workspace is connected to FirstQuadrant via Slack Connect, you can:

* Ask questions directly in the shared Slack channel and one of our team members will reply as soon as possible.
* Mention **@FirstQuadrant** to engage our AI assistant for real-time answers.

This channel is ideal for fast, collaborative troubleshooting.


# Feature preview
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/feature-preview

Enable early access to upcoming features and improvements that are currently in beta. These features are designed to enhance your experience but may still be under development.

## Overview

The **Feature preview** section in FirstQuadrant's workspace settings gives you early access to upcoming features and improvements that are currently in beta. These features are designed to enhance your experience but may still be under development.

By enabling feature previews, you can test new functionality before it becomes generally available and provide valuable feedback to help improve the platform. This allows you to stay ahead of the curve and influence the development of features that matter most to your workflow.

### What are feature previews?

Feature previews are experimental features that are being tested with a select group of users before being released to everyone. They represent the latest innovations and improvements being developed for FirstQuadrant, giving you a sneak peek at what's coming next.

### Benefits of enabling feature previews

* **Early access**: Be among the first to try new features and capabilities
* **Influence development**: Your feedback directly shapes how features are refined and improved
* **Stay competitive**: Get a head start on using cutting-edge AI sales automation tools
* **Better workflow**: Discover new ways to streamline your sales processes before they're widely available

### How feature previews work

When you enable a feature preview, it becomes available immediately across your entire workspace. The feature will appear in your interface alongside existing functionality, allowing you to seamlessly integrate it into your current workflow. You can enable or disable individual features at any time, giving you full control over which experimental features you want to test.

## Managing feature previews

To access and manage feature preview settings:

1. Navigate to **Settings** → **Workspace** → **Feature preview**
2. Toggle the switch next to any feature you'd like to enable
3. Click **Update settings** to save your changes

## Beta feature considerations

When using feature previews, keep in mind:

* **Stability**: Beta features may have occasional bugs or performance issues
* **Changes**: Features may change significantly before general release
* **Support**: Limited support may be available for beta features
* **Feedback**: Your feedback helps improve these features before general release

You can disable feature previews at any time by toggling the switches off and updating your settings.


# Workspace general settings
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/general-workspace-settings

This article explains the General Settings section in FirstQuadrant, where users can manage workspace-level details such as name, slug, legal name, website, and description. It also covers enabling sandbox mode for safe testing and how to delete the workspace.

### Overview

The **General Settings** section in FirstQuadrant’s workspace allows you to manage key workspace details such as your workspace name, legal name, slug, description, and website. This information is initially populated during signup via FirstQuadrant's internal automation, but you can edit it at any time through the settings panel.

***

### Editable fields

In this section, you can update the following:

* **Name**: This is your public-facing workspace name.
* **Slug**: This defines the URL path for your workspace (e.g., `https://app.firstquadrant.ai/your-slug`).
* **Legal name**: The official name of your company.
* **Website**: Your company's website.
* **Description**: A short explanation of what your company does. This may be used for personalization in emails and [campaigns](/product-manual/campaigns/campaign-overview).

> **Info:** You currently cannot change the workspace icon. It is automatically set during signup.

***

### Sandbox mode

You can enable **Sandbox mode** for testing purposes. When this is turned on, all outbound emails will be sent to sandbox test addresses instead of real recipients.

***

### Deleting your workspace

If you need to permanently delete your workspace, scroll down to the **Danger zone** section and click **Delete workspace**.

> **Info:** This action is irreversible. All workspace data will be permanently removed.

***


# Workspace members settings
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/members-workspace-settings

The Members workspace settings in FirstQuadrant allow you to manage team access and configuration. You can invite new members by entering their name and email—no password setup is needed. For each member, you can configure a scheduling link, email signature, and optional reply-to address. Members can be edited, deactivated (removing access but keeping synced emails), or deleted (revoking all access).

## Overview

The **Members** section under Workspace Settings in FirstQuadrant allows you to manage your team's access and configuration. Here, you can add new team members, view existing ones, and configure settings that determine how the AI interacts on behalf of each user.

## Adding new team members

To invite a new member to your workspace:

1. Navigate to **Settings** → **Workspace** → **Members**.
2. Click the **New membership** button in the top right.
3. Enter the team member’s **name** and **email address**.
4. Click **Invite member**.

> **Note:** Team members can join without needing to set a password, as long as they use the same email address.

> **Scaleup plan benefit:** If your workspace is on the **Scaleup plan**, you can add **unlimited team members for free**—there are no per-user or per-seat charges. Invite your entire team at no additional cost.

## Viewing and editing member details

Once a member is added, they appear in the membership list. Clicking on a member opens a detailed side panel with the following configurable fields:

### Scheduling link

You can add a scheduling link (e.g., from cal.com, Calendly, etc.). FirstQuadrant uses this link whenever it needs to schedule meetings on behalf of the team member. If this field is empty, the AI will not include scheduling links in messages.

### Signature

This is the closing signature that will be used in automated emails sent from this user’s identity.

### Advanced options

* **Reply-to address**:\
  Specify the email address where replies should be directed. This is useful if you want responses to go to a different inbox from the one used for sending.

## Managing memberships

To manage or remove an existing membership:

1. In the Members overview page, click on the **three-dot menu** next to a member’s name.
2. Choose one of the following options:
   * **Deactivate**: The member loses access to FirstQuadrant, but their email addresses will still be synced.
   * **Delete**: The member is fully removed and access is permanently revoked.


# Pipelines
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/pipeline-workspace-settings

This article explains how to set up and manage sales pipelines in FirstQuadrant. It covers how to create new pipelines, define deal values, configure stages with clear goals, and how FirstQuadrant’s AI uses pipeline structure to manage deal progression—including non-linear movement. Ideal for sales teams looking to align their sales process with FirstQuadrant’s automation.

## Overview

Pipelines in FirstQuadrant represent your sales process in a structured, visual way. They help the AI understand where each [deal](/product-manual/records/records-overview) stands, what should happen next, and how to progress toward closing. Every workspace starts with a default pipeline, but you can create multiple pipelines tailored to different sales motions (e.g. startups vs. enterprises).

> **Note**: Pipelines should mirror your sales funnel as closely as possible to ensure FirstQuadrant can manage deals efficiently.

***

## Accessing pipelines

Navigate to **Settings > Workspace > Pipelines** in the left sidebar. Here, you'll see a list of all existing pipelines, including the default one created at signup.

***

## Creating a new pipeline

1. Click **New pipeline** in the top right corner of the Pipelines page.
2. You’ll be directed to the pipeline creation screen where you must provide:
   * **Name**: This is the identifier for the pipeline. Choose a name that clearly reflects the type of deals that will be managed in it (e.g. "Startups", "Enterprise deals").
   * **Description**: This field is essential for FirstQuadrant’s AI. It determines which deals belong in this pipeline by analyzing context from emails, contact details, and input metadata. The description should include key criteria such as target segment, employee size, revenue bracket, years in operation, or funding stage. For example: “Startups are companies under 100 employees, \<\$10M revenue, and in early funding stages.”
   * **Default value**: A static deal value assigned to every new deal added to this pipeline. This helps in forecasting when dynamic values aren’t yet available.
   * **Valuation formula (optional)**: Here, you can instruct FirstQuadrant on how to dynamically estimate a deal’s value using a plain-English formula like "number of seats \* \$1,000." Once enough data is available in the conversation or contact context, FirstQuadrant will override the default with a dynamically calculated value.
3. When all fields are filled out, click **Create pipeline**. Your new pipeline will then appear in the pipeline overview list, ready for stage setup.

### Editing pipeline settings

To update a pipeline's name, description, or value settings, click **Settings** in the top right of the pipeline view.

***

## Adding and editing pipeline stages

Once a pipeline is created, you’ll be prompted to add stages that represent the sequential steps of your sales process. These stages help FirstQuadrant guide deals forward and understand what each step entails.

You can:

* **Choose from a template**: FirstQuadrant offers stage templates like B2B SaaS sales-led, Startup School founder-led sales, Enterprise software sales, and Consulting services. These are useful shortcuts if your sales process fits a common model.
* **Create a custom stage**: Click **Add stage** to define your own. This allows for maximum customization to mirror your unique process.

### Stage configuration

For each stage, you'll configure the following:

* **Name**: A clear, concise title for the stage (e.g. "Demo call", "Proposal"). This appears in the pipeline view and signals where the deal currently is.
* **Description**: A detailed explanation of when a deal should be considered part of this stage. This is crucial for FirstQuadrant’s AI to classify deals correctly. For example: “Deals are in this stage once a discovery call has been scheduled but a demo call has not yet taken place.”
* **Goal**: This field defines what success looks like for the stage and when the AI should consider moving the deal forward. Write this in plain English—e.g. “The prospect should schedule a demo call with us using our scheduling link.”
* **Goal URL**: This optional field supports automation around scheduling. You can either:
  * Use the **default scheduling link** set per [team member](/product-manual/workspace-settings/members-workspace-settings)
  * Or provide a **custom URL** that overrides the default for this specific stage (e.g. a unique Calendly link for a product demo)

The goal serves two essential purposes:

1. It functions as a compass: FirstQuadrant uses it to shape the conversation and guide the prospect toward achieving the next step.
2. It marks progress: Once the goal is met, the AI knows the deal is ready to advance to the next stage and does so.

Take the time to write thoughtful names, descriptions, and goals—they directly inform how FirstQuadrant orchestrates deal progression across your sales pipeline.

### Manage stages

Once stages are added, you can:

* Reorder them using the three-dot menu
* Delete, duplicate, or view associated deals

***

## Handling non-linear deal movement

While pipelines in FirstQuadrant are structured linearly to represent an ideal sales flow, the platform is built with the understanding that real-world sales are rarely that simple. Deals often deviate from a perfect sequence—and FirstQuadrant's AI is designed to handle these exceptions intelligently.

Deals may:

* **Skip stages**: For example, a prospect might move straight from "Discovery call" to "Proposal" if they’ve already been briefed.
* **Move backwards**: If a deal stalls or a stakeholder changes, the AI may decide to move it back to an earlier stage.
* **Re-enter a previous stage**: Sometimes, deals may cycle through the same stage multiple times, such as returning to "Demo call" after a follow-up is requested.

FirstQuadrant uses the full context of the conversation history, deal metadata, and pipeline configuration to determine when a deal should advance, pause, regress, or repeat a stage. This means you don’t have to enforce a rigid funnel. Instead, the AI continuously evaluates what the most logical next step is for each individual deal—ensuring flexibility while maintaining structure.

***


# Scheduling and tracking
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/scheduling-tracking

This article explains how to configure the Schedule & Tracking settings in FirstQuadrant. This section allows you to define the cadence of automated follow-ups, control sending schedules based on time zones, and manage email tracking preferences to optimize deliverability.

## Accessing schedule & tracking

To access these settings, go to:\
**Settings** → **Workspace** → **Schedule & tracking**

***

## Follow-up configuration

In this section, you define how many follow-up emails FirstQuadrant should prepare after a reply message and at what intervals. After approval these follow-ups are automatically scheduled and generated unless the contact responds earlier.

By default, FirstQuadrant creates **three follow-up emails**, spaced as follows:

* **1st follow-up:** 3 days after the first email is sent
* **2nd follow-up:** 5 days after the first follow-up (i.e., on day 8)
* **3rd follow-up:** 8 days after the second follow-up (i.e., on day 16)

This setup creates a gradually increasing delay between emails—also known as a progressive cadence—designed to reduce fatigue while maintaining engagement.

The default recipe is used by FirstQuadrant when dynamically generating email replies. You can easily tailor this:

* **Add a new follow-up** by clicking the **+ Add follow-up** button and specifying the interval after the previous message
* **Delete a follow-up** by clicking the delete icon next to any listed follow-up

You can customize as many follow-up steps as you want. These settings ensure that follow-ups are spaced intentionally and adaptively without needing to manually build sequences each time.

> **Info**: If you want to change the content or tone of the follow-up emails generated by FirstQuadrant, you can do so by creating a **[general fine-tuning rule](/product-manual/fine-tuning/create-fine-tuning)** in the **[Fine-tuning](/product-manual/fine-tuning/fine-tuning-overview)** settings. These rules let you guide how the AI composes responses for your entire workspace.

***

## Sending schedule

The sending schedule determines the days and times during which FirstQuadrant is allowed to send emails.

* By default, emails are sent based on the **time zone of the recipient**.
* You can override this and choose a specific time zone manually from the dropdown.

For each weekday, you can define active sending hours (e.g., 08:00–20:00). This is useful for:

* Respecting working hours across geographies
* Avoiding off-hour or weekend sends during bulk outreach

***

## Email tracking

At the bottom of the settings page, you can manage email tracking options:

### Open tracking

Control how FirstQuadrant tracks email opens:

* **Sampled tracking (recommended)**: Tracks a subset of emails to estimate open rates while preserving deliverability. You'll see aggregate statistics at the campaign or input level.
* **Track all emails**: Includes a tracking pixel in every email for precise, per-email open data. This provides maximum visibility but may slightly impact deliverability.

Toggle the **"Include open tracking pixel in all emails"** option to switch between sampled and full tracking modes. When disabled (default), FirstQuadrant uses intelligent sampling to balance tracking accuracy with deliverability.

### Click tracking

* **Click tracking**: Tracks when recipients click on links within the emails

**Deliverability considerations:**\
While full tracking provides complete visibility, sampled tracking is generally recommended for most use cases as it maintains optimal deliverability rates. Consider using full tracking only for high-priority campaigns where detailed engagement metrics are critical.


# Suggested imports
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/suggested-imports

Suggested imports in FirstQuadrant help keep your contact database automatically up-to-date by scanning your email conversations and recommending contacts to import. This feature is designed to ensure you never miss adding an important point of contact and helps populate your action list with meaningful follow-ups. This is enabled by default and focus on contacts from sales-related conversations.

## How suggested imports work

FirstQuadrant continuously analyzes your connected email and calendar accounts. When it identifies a person you're actively communicating with—typically in a sales context—who isn't yet part of your FirstQuadrant workspace, it creates a **suggested import** to import that contact. These suggested imports are shown in your **[Actions](/product-manual/actions)** list, where you can either approve (import) or ignore them.

These suggested imports are only created for sales-related conversations by default, but this behavior can be customized.

***

## Configuring suggested imports

You can configure how suggested imports work under: **Settings → Workspace → Suggested imports**

### Enable suggested imports

Choose what kinds of contacts FirstQuadrant should monitor for suggested imports:

* **Suggest importing contacts from sales-related conversations** (default): Only suggests contacts if the AI believes the conversation is sales-related.
* **Suggest importing all discovered contacts**: Suggests importing every new contact found in your inbox, regardless of context.
* **Disable suggested imports**: Turns off the contact suggested import feature entirely.

### Autopilot

If suggested imports are enabled, you can optionally enable Autopilot to bypass manual approval:

* **Enabled for sales-related conversations only**: Automatically imports suggested imports if they are sales-related.
* **Enabled for all discovered contacts**: Automatically imports all new contacts found via email or calendar.
* **Disabled** (default): Suggested imports are created but require your approval before importing.

### Maximum suggested imports per day

Limit the number of suggested imports created per day to avoid overload. For example, setting this to 10 will limit FirstQuadrant to surfacing 10 contact suggested imports per day.

### Fine-tuning instructions

You can provide custom instructions to help FirstQuadrant better understand what constitutes a sales opportunity in your specific business context. This field allows you to:

* Define specific keywords, phrases, or patterns that indicate sales conversations
* Exclude certain types of communications (e.g., support tickets, internal discussions)
* Specify industry-specific terminology or criteria
* Set rules for when contacts should or shouldn't be created

For example, you might add instructions like:

* "Only consider conversations with VP-level or above as sales opportunities"
* "Exclude any emails containing 'support ticket' or 'invoice'"
* "Include conversations about 'enterprise licensing' or 'annual contracts'"

These instructions help the AI make more accurate decisions when analyzing your emails and determining which contacts to suggest for import.

***

## Overriding suggested imports per email account

In the advanced settings of individual email accounts (**Settings → Integrations → [Email accounts](/product-manual/integrations-settings/email-accounts)**), you can override the global workspace settings for suggested imports. This allows you to customize suggested imports on a per-account basis. For example, you can:

* Disable suggested imports entirely for a specific account.
* Choose to import **only** sales-related contacts.
* Choose to import **all** discovered contacts.

This is useful if some inboxes are dedicated to marketing, support, or external roles where importing contacts might not be necessary or desired.

***

## Best practices

* Use **Autopilot** if you're confident in FirstQuadrant’s contact identification and want a hands-off experience.
* Keep **suggestions limited to sales-related conversations** for a more curated contact list.
* Regularly check your **[Actions](/product-manual/actions)** list to review and approve or ignore pending suggested imports.

***


# Workspace teams settings
Source: https://docs.firstquadrant.ai/product-manual/workspace-settings/teams-workspace-settings

This article explains how to create and manage teams in FirstQuadrant. Teams help organize your sales organization, streamline campaign targeting, and enable better collaboration by grouping members for role-based workflows and access segmentation.

## Overview

The *Teams* setting in FirstQuadrant allows you to organize your sales organization into logical groups. These groups—referred to as teams—make collaboration easier and enable more structured campaign targeting and role-based workflows across the platform.

## Creating a team

To create a new team:

1. Navigate to **Settings** > **Workspace** > **Teams**.
2. Click on the **New team** button in the top-right corner.
3. Enter a **team name** (e.g., *Outbound Team*, *Inside Sales*, *Customer Success*).
4. Select the relevant **team members** from the dropdown list.
5. Click **Create team** to confirm.

Each team can contain any number of members, and team assignments can be changed at any time.

## Use cases for teams

Teams can be used throughout FirstQuadrant in several ways, including:

* **Campaign targeting**: When setting up [campaigns](/product-manual/campaigns/campaign-overview), you can select an entire team as the sender group.
* **Access control and segmentation**: Teams help segment your sales org for better visibility and management.