Installation

Open Claude Code and run this command:

/plugin install finta-pack@claude-code-plugins-plus

Use --global to install for all projects, or --project for current project only.

Skills (18)

finta-ci-integration SKILL.md View full skill →

Automate Finta data export and reporting in CI pipelines.

ReadWriteEdit

Finta CI Integration

Overview

Set up CI/CD for Finta fundraising integrations: run unit tests with mocked investor pipeline data on every PR, validate live API connectivity for round and investor queries on merge to main. Finta centralizes fundraising CRM data including rounds, investor contacts, and pipeline stages, so CI focuses on verifying data sync logic, pipeline stage transitions, and automated investor reporting workflows.

GitHub Actions Workflow


# .github/workflows/finta-ci.yml
name: Finta CI
on:
  pull_request:
    paths: ['src/finta/**', 'tests/**']
  push:
    branches: [main]

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci
      - run: npm test -- --reporter=verbose

  integration-tests:
    if: github.ref == 'refs/heads/main'
    needs: unit-tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci
      - run: npm run test:integration
        env:
          FINTA_API_KEY: ${{ secrets.FINTA_API_KEY }}

Mock-Based Unit Tests


// tests/finta-service.test.ts
import { describe, it, expect, vi } from 'vitest';
import { summarizeRound } from '../src/finta-service';

const mockRound = {
  id: 'round_seed_01',
  name: 'Seed Round',
  target_amount: 2_000_000,
  raised_amount: 1_250_000,
  investors: [
    { name: 'Acme Ventures', committed: 500_000, stage: 'committed' },
    { name: 'Beta Capital', committed: 750_000, stage: 'committed' },
  ],
};

vi.mock('../src/finta-client', () => ({
  FintaClient: vi.fn().mockImplementation(() => ({
    getRound: vi.fn().mockResolvedValue(mockRound),
    listInvestors: vi.fn().mockResolvedValue({ investors: mockRound.investors, total: 2 }),
    getPipelineSummary: vi.fn().mockResolvedValue({ stages: { committed: 2, in_progress: 3 } }),
  })),
}));

describe('Finta Service', () => {
  it('summarizes fundraising round progress', async () => {
    const summary = await summarizeRound('round_seed_01');
    expect(summary.percentRaised).toBeCloseTo(62.5);
    expect(summary.investorCount).toBe(2);
  });
});

Integration Tests


// tests/integration/finta.integration.test.ts
import { describe, it, expect } from 'vitest';

const hasKey = !!process.env.FINTA_API_KEY;

describe.skipIf(!hasKey)('Finta Live API', () => {
  it('lists fundraising rounds', async () => {
    const res = await fetch('https://api.finta.io/v1/rounds', {
      headers: { Authorization: `Bearer ${process.env.FINTA_API_KEY}` },
    });


                
                  
                  
                  finta-common-errors
                  SKILL.md
                  View full skill →
                
                
                  Diagnose and fix common Finta CRM issues with email sync, deal rooms, and pipeline.
                  
                      ReadGrep
                    
                
                
                  Finta Common Errors
Overview
Finta is a fundraising CRM that manages investor pipelines, deal rooms, email sync, and payment collection for startups raising capital. Common errors involve round state transition violations (e.g., moving a round backward from "Closing" to "Outreach"), investor deduplication failures during CSV imports, and pipeline sync breakdowns between email providers and the deal tracker. Aurora AI suggestions depend on complete company profiles, and incomplete data is the top cause of empty recommendations. This reference covers API-level errors and CRM workflow issues that disrupt fundraising operations.
Error Reference

Code
Message
Cause
Fix


400
Invalid round transition
Moving round to an invalid state
Follow valid transitions: Draft > Active > Closing > Closed


401
Invalid API key
Expired or revoked FINTAAPIKEY
Regenerate at Settings > API Access


404
Investor not found
Deleted or merged investor record
Search by email to find merged record


409
Duplicate investor
Email already exists in pipeline
Use dedup endpoint before CSV import


422
Missing required fields
Incomplete investor or round data
Include name, email, stage at minimum


429
Rate limit exceeded
Too many API calls
Implement backoff; batch operations where possible


500
Pipeline sync failed
Email provider OAuth expired
Reconnect Gmail/Outlook at Settings > Integrations


502
Stripe webhook failed
Payment collection error
Verify Stripe integration and webhook URL


Error Handler

interface FintaError {
  code: number;
  message: string;
  category: "auth" | "rate_limit" | "validation" | "sync";
}

function classifyFintaError(status: number, body: string): FintaError {
  if (status === 401) {
    return { code: 401, message: body, category: "auth" };
  }
  if (status === 429) {
    return { code: 429, message: "Rate limit exceeded", category: "rate_limit" };
  }
  if (status === 400 || status === 404 || status === 409 || status === 422) {
    return { code: status, message: body, category: "validation" };
  }
  return { code: status, message: body, category: "sync" };
}


                
                  
                  
                  finta-core-workflow-a
                  SKILL.md
                  View full skill →
                
                
                  Manage a fundraise pipeline end-to-end with Finta.
                  
                      ReadWriteEditGrep
                    
                
                
                  Finta Core Workflow: Fundraise Pipeline
Overview
End-to-end fundraise management with Finta: prospect investors, manage outreach, track meetings, handle due diligence, and close commitments.
Instructions
Step 1: Investor Prospecting with Aurora AI
Aurora AI analyzes your company profile and recommends investors based on:

Thesis alignment (sector, stage, geography)
Historical investment behavior
Warm introduction availability from your network

Navigate to Investors > Discover and review AI-ranked suggestions.
Step 2: Outreach Campaign

Select investors to contact
Use Finta's AI-assisted email composer for personalized outreach
Finta auto-tracks replies and updates pipeline stages

Stage automation rules:

Investor opens email --> "Reaching Out" (stays)
Investor replies --> auto-advance to "Intro Meeting"
Meeting scheduled --> confirm via calendar sync

Step 3: Deal Room Setup
For each active conversation:

Create a Deal Room with relevant materials
Upload: pitch deck, financial model, cap table, team bios
Share link with investor
Monitor analytics: views, time spent, pages viewed

Step 4: Due Diligence Management

Create a Data Room for detailed document sharing
Organize by category: legal, financial, technical, team
Set permission-based access (view-only, download, etc.)
Track which documents investors have reviewed

Step 5: Close and Collect

Move investor to "Term Sheet" stage when term sheet received
Review terms in Finta's term sheet comparison view
Accept and move to "Closed"
Use Stripe/ACH integration to send payment links
Collect committed capital directly through Finta

Fundraise Metrics Dashboard
Track in Finta or export for custom analysis:

Total pipeline value
Conversion rate by stage
Average time in each stage
Top investor engagement (deal room views)
Warm intro utilization rate

Error Handling

Issue
Cause
Solution


Emails not tracking
OAuth disconnected
Reconnect in Settings


Deal room views not logging
Browser blocking
Share via direct email


Payment link expired
Stripe session timeout
Generate new link


Aurora suggestions poor
Incomplete profile
Complete all company fields


Resources

Fint


                
                  
                  
                  finta-core-workflow-b
                  SKILL.md
                  View full skill →
                
                
                  Manage ongoing investor relations and updates with Finta.
                  
                      ReadWriteEditGrep
                    
                
                
                  Finta Core Workflow: Investor Relations
Overview
Post-fundraise investor management: send periodic updates, share metrics, manage cap table, and maintain relationships for future rounds.
Instructions
Investor Updates

Go to Updates > New Update
Select template (monthly, quarterly, or custom)
Finta auto-populates metrics from connected financial tools:


MRR/ARR from Stripe
Cash and burn rate from Mercury/Brex
Runway calculation


Add qualitative updates (milestones, challenges, asks)
Send to all investors or select groups

Update Template

Subject: [Company] Monthly Update - March 2026

Key Metrics:
- MRR: $X (up Y% MoM)
- ARR: $X
- Burn Rate: $X/month
- Runway: X months
- Headcount: X

Highlights:
- [Achievement 1]
- [Achievement 2]

Challenges:
- [Challenge and plan to address]

Asks:
- Introductions to [specific companies/people]
- Feedback on [specific topic]

Warm Introduction Network
Finta's network feature identifies 2nd-degree connections:

Go to Network > Find Introductions
Select target investor
Finta shows mutual connections from your team, advisors, and existing investors
Request introduction through the platform

Cap Table Tracking

Import cap table from Carta, Pulley, or CSV
Track ownership percentages after each round
Model dilution for future rounds
Export for legal and compliance

Resources

Finta for Fund Managers

Next Steps
For troubleshooting, see finta-common-errors.


                
                  
                  
                  finta-cost-tuning
                  SKILL.md
                  View full skill →
                
                
                  Optimize Finta plan selection and feature usage.
                  
                      ReadGrep
                    
                
                
                  Finta Cost Tuning
Overview
Finta pricing is per-seat with tiered feature access, and the primary cost driver is investor pipeline sync volume. Each fundraising round generates hundreds of investor interactions — updates, document shares, and payment collections — that all flow through Finta's API. Over-syncing investor data, maintaining unused deal rooms, and keeping inactive seats during non-fundraising periods waste budget. Strategic plan selection and sync optimization ensure you only pay for what active fundraising demands.
Cost Breakdown

Component
Cost Driver
Optimization


Seat licenses
Per-user/month pricing
Remove seats between fundraising rounds


Deal rooms
Each active deal room consumes quota
Archive completed deal rooms promptly


Investor pipeline syncs
API calls per investor update
Batch investor updates; sync only changed records


Payment processing
Stripe/ACH transaction fees
Consolidate payment rounds to minimize transactions


Document sharing
Storage and delivery per shared document
Deduplicate documents; use shared links over copies


API Call Reduction

class FintaPipelineSync {
  private lastSyncTimestamp = 0;
  private investorCache = new Map<string, { data: any; hash: string }>();

  async incrementalSync(investors: any[]): Promise<any[]> {
    const changed = investors.filter(inv => {
      const cached = this.investorCache.get(inv.id);
      const currentHash = this.hashInvestor(inv);
      if (cached && cached.hash === currentHash) return false;
      this.investorCache.set(inv.id, { data: inv, hash: currentHash });
      return true;
    });
    // Only sync investors with actual changes — typically reduces calls by 60-80%
    return this.batchUpdate(changed);
  }

  private hashInvestor(inv: any): string {
    return JSON.stringify({ status: inv.status, amount: inv.amount, stage: inv.stage });
  }

  private async batchUpdate(investors: any[]): Promise<any[]> {
    // Chunk into batches of 25 to stay within rate limits
    const size = 25;
    const batches = Array.from({ length: Math.ceil(investors.length / size) },
      (_, i) => investors.slice(i * size, i * size + size));
    return Promise.all(batches.map(batch => fetch('/api/investors/bulk', {
      method: 'POST', body: JSON.stringify(batch)
    })));
  }
}

Usage Monitoring

class FintaCostTracker {
  private syncsToday = 0;
  private dailyBudget = 500;

  recordSync(investorCount: number): void {
    this.syncsToday += investorCount;
    const utilization = (this.syncsToday / this.dailyBudget) * 100;
    if (utilization


                
                  
                  
                  finta-debug-bundle
                  SKILL.md
                  View full skill →
                
                
                  Collect Finta diagnostic information for support.
                  
                      ReadGrep
                    
                
                
                  Finta Debug Bundle
Overview
Collect Finta API connectivity status, fundraising round data, investor pipeline health, and integration state into a single diagnostic archive. This bundle helps troubleshoot CRM sync failures, missing investor records, round update errors, and authentication problems. Attach the output to Finta support tickets for faster resolution of fundraising workflow issues.
Debug Collection Script

#!/bin/bash
set -euo pipefail
BUNDLE="debug-finta-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$BUNDLE"

# Environment check
echo "=== Finta Debug Bundle ===" | tee "$BUNDLE/summary.txt"
echo "Generated: $(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$BUNDLE/summary.txt"
echo "FINTA_API_KEY: ${FINTA_API_KEY:+[SET]}" >> "$BUNDLE/summary.txt"

# API connectivity
HTTP=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer ${FINTA_API_KEY}" \
  https://api.finta.io/v1/rounds 2>/dev/null || echo "000")
echo "API Status: HTTP $HTTP" >> "$BUNDLE/summary.txt"

# Fundraising rounds summary
curl -s -H "Authorization: Bearer ${FINTA_API_KEY}" \
  "https://api.finta.io/v1/rounds" \
  > "$BUNDLE/rounds.json" 2>&1 || true

# Investor records (limited)
curl -s -H "Authorization: Bearer ${FINTA_API_KEY}" \
  "https://api.finta.io/v1/investors?limit=10" \
  > "$BUNDLE/investors-sample.json" 2>&1 || true

# Connected integrations status
curl -s -H "Authorization: Bearer ${FINTA_API_KEY}" \
  "https://api.finta.io/v1/integrations" \
  > "$BUNDLE/integrations.json" 2>&1 || true

# Rate limit headers
curl -s -D "$BUNDLE/rate-headers.txt" -o /dev/null \
  -H "Authorization: Bearer ${FINTA_API_KEY}" \
  https://api.finta.io/v1/rounds 2>/dev/null || true

tar -czf "$BUNDLE.tar.gz" "$BUNDLE" && rm -rf "$BUNDLE"
echo "Bundle: $BUNDLE.tar.gz"

Analyzing the Bundle

tar -xzf debug-finta-*.tar.gz
cat debug-finta-*/summary.txt                  # Auth + connectivity overview
jq '.[] | {id, name, status}' debug-finta-*/rounds.json  # Active rounds
jq 'length' debug-finta-*/investors-sample.json          # Investor count check
grep -i "ratelimit\|retry" debug-finta-*/rate-headers.txt

Common Issues

Symptom
Check in Bundle
Fix


API returns 401
summary.txt shows HTTP 401
Regenerate API key in Finta Settings > API Keys


Rounds list empty
rounds.json returns empty array
Verify rounds exist in Finta dashboard; check workspace permi
                
              
                
                  
                  
                  finta-deploy-integration
                  SKILL.md
                  View full skill →
                
                
                  Deploy Finta integrations and reporting dashboards.
                  
                      ReadWriteEdit
                    
                
                
                  Finta Deploy Integration
Overview
Deploy a containerized Finta fundraising integration service with Docker. This skill covers building a production image that connects to the Finta API for managing fundraising rounds, investor pipelines, and deal flow analytics. Includes environment configuration for multi-round tracking, health checks that verify API connectivity to Finta's investor management endpoints, and rolling update strategies for zero-downtime deployments during active fundraising campaigns.
Docker Configuration

FROM node:20-slim AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY tsconfig.json ./
COPY src/ ./src/
RUN npm run build

FROM node:20-slim
RUN addgroup --system app && adduser --system --ingroup app app
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
USER app
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1
CMD ["node", "dist/index.js"]

Environment Variables

export FINTA_API_KEY="finta_live_xxxxxxxxxxxx"
export FINTA_BASE_URL="https://api.trustfinta.com/v1"
export FINTA_WORKSPACE_ID="ws_xxxxxxxxxxxx"
export LOG_LEVEL="info"
export PORT="3000"
export NODE_ENV="production"

Health Check Endpoint

import express from 'express';

const app = express();

app.get('/health', async (req, res) => {
  try {
    const response = await fetch(`${process.env.FINTA_BASE_URL}/rounds`, {
      headers: { 'Authorization': `Bearer ${process.env.FINTA_API_KEY}` },
    });
    if (!response.ok) throw new Error(`Finta API returned ${response.status}`);
    res.json({ status: 'healthy', service: 'finta-integration', timestamp: new Date().toISOString() });
  } catch (error) {
    res.status(503).json({ status: 'unhealthy', error: (error as Error).message });
  }
});

Deployment Steps
Step 1: Build

docker build -t finta-integration:latest .

Step 2: Run

docker run -d --name finta-integration \
  -p 3000:3000 \
  -e FINTA_API_KEY -e FINTA_BASE_URL -e FINTA_WORKSPACE_ID \
  finta-integration:latest

Step 3: Verify

curl -s http://localhost:3000/health | jq .

Step 4: Rolling Update

docker build -t finta-integration:v2 . && \
docker stop finta-integration && \
docker rm finta-integration && \
docker run -d --name finta-integration -p 3000:3000 \
  -e FINTA_API_KEY -e FINTA_BASE_URL -e FINTA_WORKSPACE_ID \
  finta-integration:v2

Error Handling
                
              

                
                  
                  
                  finta-hello-world
                  SKILL.md
                  View full skill →
                
                
                  Set up your first fundraise pipeline in Finta with investors and deal stages.
                  
                      ReadWriteEdit
                    
                
                
                  Finta Hello World
Overview
Create your first fundraise pipeline in Finta: add target investors, configure deal stages, and use Aurora AI for investor prospecting.
Prerequisites

Completed finta-install-auth setup
Basic company information entered

Instructions
Step 1: Create a New Fundraise

Click New Fundraise in the dashboard
Enter details: round name, target amount, equity type (SAFE, Priced, Convertible Note)
Set timeline and target close date

Step 2: Add Target Investors
Manual Entry:

Click Add Investor in pipeline view
Enter: investor name, firm, email, check size range, thesis tags

CSV Import:

Name,Firm,Email,Check Size,Stage,Notes
Jane Smith,Sequoia Capital,jane@sequoia.com,"$500K-$2M",Researching,Met at TechCrunch
Bob Jones,a16z,bob@a16z.com,"$1M-$5M",Reaching Out,Intro from advisor

Aurora AI Prospecting:

Go to Investors > Discover
Aurora ranks investors by thesis fit, check size match, and warm intro availability
Add promising matches to your pipeline with one click

Step 3: Track Pipeline Progress
Finta automatically moves investors through stages based on:

Email replies: Investor responds --> auto-advance to next stage
Calendar meetings: Meeting scheduled --> advance to Intro Meeting
Manual updates: Drag-and-drop in pipeline Kanban view

Step 4: Set Up Deal Room

Navigate to Deal Rooms > Create Deal Room
Upload fundraising materials: pitch deck, financials, cap table
Generate shareable link with view tracking
Monitor who viewed what and for how long

Step 5: Send Investor Update

Go to Updates > New Update
Select metrics to include: MRR, ARR, burn rate, runway
Finta auto-populates from connected financial data
Send to all investors or select groups

Output

Active fundraise pipeline with investors in stages
Deal room with shared materials and analytics
Email/calendar sync tracking communications automatically

Error Handling

Issue
Cause
Solution


Investors not advancing
Auto-rules disabled
Check Settings > Automation


Deal room link broken
Expired share
Regenerate link


Metrics not populating
No financial integration
Connect Stripe/Mercury/Brex<
                
              
                
                  
                  
                  finta-install-auth
                  SKILL.md
                  View full skill →
                
                
                  Set up Finta fundraising CRM account and configure integrations.
                  
                      ReadWriteEditBash(curl:*)Grep
                    
                
                
                  Finta Install & Auth
Overview
Set up Finta fundraising CRM at trustfinta.com. Finta is a UI-first platform for managing fundraising pipelines, investor relationships, and deal rooms. Integration is via email/calendar sync and the Finta web app -- there is no public REST API.
Prerequisites

Finta account at https://www.trustfinta.com
Gmail or Outlook email for sync
Google Calendar or Outlook Calendar

Instructions
Step 1: Create Account

Sign up at https://www.trustfinta.com
Complete onboarding wizard with company details
Select your fundraising stage (Pre-seed, Seed, Series A, etc.)

Step 2: Connect Email
Finta syncs with Gmail and Outlook to automatically track investor communications:

Go to Settings > Integrations
Click Connect Gmail or Connect Outlook
Grant read access for email tracking
Finta will auto-detect investor conversations and update pipeline stages

Step 3: Connect Calendar

Go to Settings > Integrations
Click Connect Google Calendar or Connect Outlook Calendar
Meetings with investors will auto-log to the pipeline

Step 4: Import Existing Investors

CSV Import: Upload a spreadsheet with investor name, firm, email, stage
Manual Entry: Add investors one by one in the Pipeline view
Aurora AI: Let Finta's AI prospect matching find relevant investors

Step 5: Configure Pipeline Stages
Default stages (customizable):

Researching
Reaching Out
Intro Meeting
Follow-up
Due Diligence
Term Sheet
Closed

Error Handling

Issue
Cause
Solution


Email sync not working
OAuth expired
Reconnect in Settings > Integrations


Calendar events missing
Wrong calendar selected
Select correct calendar


CSV import fails
Wrong format
Use Finta template CSV


Duplicate investors
Re-import
Merge duplicates in UI


Resources

Finta Website
Finta Blog
Finta for Serial Entrepreneurs

Next Steps
Proceed to finta-hello-world to set up your first fundraise pipeline.
                
              

                
                  
                  
                  finta-local-dev-loop
                  SKILL.md
                  View full skill →
                
                
                  Set up Finta workflow automation and data export for local analysis.
                  
                      ReadWriteEditBash(python3:*)Grep
                    
                
                
                  Finta Local Dev Loop
Overview
Finta is primarily UI-driven without a public API. For local automation, use CSV exports from Finta combined with Python scripts for analysis, reporting, and integration with other tools.
Instructions
Export Pipeline Data

In Finta, go to Pipeline > Export > CSV
Save as pipeline-export.csv

Analyze Fundraise Pipeline

import pandas as pd
from datetime import datetime

# Load Finta export
df = pd.read_csv("pipeline-export.csv")

# Pipeline summary
summary = df.groupby("Stage").agg(
    count=("Name", "count"),
    avg_check=("Check Size", "mean"),
).reset_index()

print("Pipeline Summary:")
print(summary.to_string(index=False))

# Conversion rates
stages = ["Researching", "Reaching Out", "Intro Meeting", "Follow-up", "Due Diligence", "Term Sheet", "Closed"]
for i in range(len(stages) - 1):
    current = len(df[df["Stage"] == stages[i]])
    next_stage = len(df[df["Stage"] == stages[i+1]])
    rate = (next_stage / current * 100) if current > 0 else 0
    print(f"  {stages[i]} -> {stages[i+1]}: {rate:.0f}%")

Weekly Pipeline Report

def generate_weekly_report(df: pd.DataFrame) -> str:
    total = len(df)
    active = len(df[df["Stage"].isin(["Intro Meeting", "Follow-up", "Due Diligence"])])
    term_sheets = len(df[df["Stage"] == "Term Sheet"])
    closed = len(df[df["Stage"] == "Closed"])

    return f"""
Fundraise Pipeline Report ({datetime.now().strftime('%Y-%m-%d')})
==================================================
Total investors: {total}
Active conversations: {active}
Term sheets: {term_sheets}
Closed: {closed}
"""

Resources

Finta Website

Next Steps
See finta-sdk-patterns for integration patterns.
                
              

                
                  
                  
                  finta-performance-tuning
                  SKILL.md
                  View full skill →
                
                
                  Optimize Finta fundraise workflow efficiency.
                  
                      ReadGrep
                    
                
                
                  Finta Performance Tuning
Overview
Finta's fundraising API handles investor list pagination, round data aggregation, and CRM sync batching. Founders querying large investor databases (1,000+ contacts) hit pagination bottlenecks, while round aggregation across multiple funding stages compounds latency. Optimizing paginated fetches with cursor-based iteration, caching investor profiles, and batching CRM sync writes reduces pipeline load times by 50-70% and keeps fundraising dashboards responsive during active rounds.
Caching Strategy

const cache = new Map<string, { data: any; expiry: number }>();
const TTL = { investors: 600_000, rounds: 300_000, pipeline: 120_000 };

async function cached(key: string, ttlKey: keyof typeof TTL, fn: () => Promise<any>) {
  const entry = cache.get(key);
  if (entry && entry.expiry > Date.now()) return entry.data;
  const data = await fn();
  cache.set(key, { data, expiry: Date.now() + TTL[ttlKey] });
  return data;
}
// Investor profiles change rarely (10 min). Pipeline stages are volatile (2 min).

Batch Operations

async function syncInvestorsBatch(client: any, cursor?: string, pageSize = 100) {
  const allInvestors = [];
  let nextCursor = cursor;
  do {
    const page = await client.listInvestors({ cursor: nextCursor, limit: pageSize });
    allInvestors.push(...page.data);
    nextCursor = page.next_cursor;
    if (nextCursor) await new Promise(r => setTimeout(r, 200));
  } while (nextCursor);
  return allInvestors;
}

Connection Pooling

import { Agent } from 'https';
const agent = new Agent({ keepAlive: true, maxSockets: 8, maxFreeSockets: 4, timeout: 30_000 });
// Finta API calls are lightweight — moderate socket count suffices

Rate Limit Management

async function withRateLimit(fn: () => Promise<any>): Promise<any> {
  const res = await fn();
  const remaining = parseInt(res.headers?.['x-ratelimit-remaining'] || '50');
  if (remaining < 3) {
    const resetMs = parseInt(res.headers?.['x-ratelimit-reset'] || '5') * 1000;
    await new Promise(r => setTimeout(r, resetMs));
  }
  return res;
}

Monitoring

const metrics = { apiCalls: 0, cacheHits: 0, syncErrors: 0, avgLatencyMs: 0 };
function track(startMs: number, cached: boolean, error?: boolean) {
  metrics.apiCalls++;
  metrics.avgLatencyMs = (metrics.avgLatencyMs * (metrics.apiCalls - 1) + (Date.now() - startMs)) / metrics.apiCalls;
  if (cached) metrics.cacheHits++; if (error) metrics.syncErrors++;
}

Performance Checklist

[ ] Use cursor-based pagination for investor lists (not offset)
[ ] Cache investor profiles with 10-min TTL
[ 
                
              

                
                  
                  
                  finta-prod-checklist
                  SKILL.md
                  View full skill →
                
                
                  Fundraise launch checklist using Finta CRM.
                  
                      ReadGrep
                    
                
                
                  Finta Production Checklist
Overview
Finta is a fundraising CRM for managing investor pipeline, deal rooms, and round tracking. A production integration syncs investor communications, manages deal room access, and automates pipeline stage transitions. Failures mean lost investor touchpoints, broken deal room links, or pipeline data that drifts from your actual fundraise state.
Authentication & Secrets

[ ] FINTAAPIKEY stored in secrets manager (not config files)
[ ] OAuth tokens for email/calendar sync stored securely
[ ] Key rotation schedule documented (before each fundraise round)
[ ] Separate credentials for staging/prod environments
[ ] Deal room access tokens scoped per investor group

API Integration

[ ] Production base URL configured (https://api.finta.com/v1)
[ ] Rate limit handling with exponential backoff
[ ] Pipeline stage sync tested with all custom stages
[ ] Investor contact import validated (deduplication on email)
[ ] Deal room link generation tested with expiration settings
[ ] Email sync webhook configured for reply-to-stage automation
[ ] Financial data integrations verified (Stripe, Mercury, Brex)

Error Handling & Resilience

[ ] Circuit breaker configured for Finta API outages
[ ] Retry with backoff for 429/5xx responses
[ ] Email sync failure detection (stale inbox = missed investor replies)
[ ] Deal room link expiration alerts before investor meetings
[ ] Duplicate investor detection on bulk import
[ ] Cap table import validation (share counts, ownership percentages)

Monitoring & Alerting

[ ] API latency tracked per endpoint (pipeline, investors, rooms)
[ ] Error rate alerts set (threshold: any sync failure during active round)
[ ] Investor reply detection latency monitored (<5 min SLA)
[ ] Deal room access analytics reviewed weekly
[ ] Pipeline stage transition audit log enabled

Validation Script

async function checkFintaReadiness(): Promise<void> {
  const checks: { name: string; pass: boolean; detail: string }[] = [];
  // API connectivity
  try {
    const res = await fetch('https://api.finta.com/v1/pipeline', {
      headers: { Authorization: `Bearer ${process.env.FINTA_API_KEY}` },
    });
    checks.push({ name: 'Finta API', pass: res.ok, detail: res.ok ? 'Connected' : `HTTP ${res.status}` });
  } catch (e: any) { checks.push({ name: 'Finta API', pass: false, detail: e.message }); }
  // Credentials present
  checks.push({ name: 'API Key Set', pass: !!process.env.FINTA_API_KEY, detail: process.env.FINTA_API_KEY ? 'Present' : 'MISSING' });
  // Pipeline stages configured
  try

                

              

                
                  
                  
                  finta-rate-limits
                  SKILL.md
                  View full skill →
                
                
                  Understand Finta usage limits and plan tiers.
                  
                      Read
                    
                
                
                  Finta Rate Limits
Overview
Finta operates as a web-first fundraising platform without a traditional REST API, so rate limits manifest as plan-tier usage caps rather than HTTP request quotas. When building integrations through Finta's webhook events or Zapier connectors, the bottleneck is typically the number of investor pipeline records, deal room operations, and Aurora AI suggestion calls you can make within your plan tier. Teams running active fundraising rounds need to understand these ceilings to avoid mid-raise disruptions.
Rate Limit Reference

Endpoint / Feature
Limit
Window
Scope


Investor pipeline records
50 (Free) / Unlimited (Pro)
Rolling
Per workspace


Deal room creation
1 (Free) / Unlimited (Pro)
Rolling
Per workspace


Aurora AI suggestions
10/day (Free) / 100/day (Pro)
24 hours
Per user


Webhook event delivery
100 events
1 minute
Per workspace


Data room file uploads
25 (Free) / Unlimited (Pro)
Rolling
Per deal room


Rate Limiter Implementation

class FintaUsageTracker {
  private counts: Map<string, { used: number; limit: number; resetAt: number }> = new Map();

  register(resource: string, limit: number, windowMs: number) {
    this.counts.set(resource, { used: 0, limit, resetAt: Date.now() + windowMs });
  }

  async acquire(resource: string): Promise<boolean> {
    const entry = this.counts.get(resource);
    if (!entry) throw new Error(`Unknown resource: ${resource}`);
    if (Date.now() > entry.resetAt) { entry.used = 0; entry.resetAt = Date.now() + 86_400_000; }
    if (entry.used >= entry.limit) return false;
    entry.used++;
    return true;
  }

  remaining(resource: string): number {
    const entry = this.counts.get(resource);
    return entry ? entry.limit - entry.used : 0;
  }
}

const tracker = new FintaUsageTracker();
tracker.register("aurora_suggestions", 100, 86_400_000);
tracker.register("webhook_events", 100, 60_000);

Retry Strategy

async function fintaWebhookRetry(payload: any, webhookUrl: string, maxRetries = 3): Promise<void> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const res = await fetch(webhookUrl, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
      });
      if (res.ok) return;
      if (res.status === 429) {
        const delay = Math.pow(2, attempt) * 5000 + Math.random() * 2000;
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      th

                

              

                
                  
                  
                  finta-reference-architecture
                  SKILL.md
                  View full skill →
                
                
                  Reference architecture for fundraising operations with Finta CRM.
                  
                      ReadGrep
                    
                
                
                  Finta Reference Architecture
Overview
Production architecture for fundraising operations integrating with Finta's CRM platform. Designed for startup founders and fund managers who need investor pipeline visibility, automated round management, and document room analytics. Key design drivers: deal velocity tracking, investor communication audit trail, capital collection automation via Stripe, and CRM integration with external systems like HubSpot or Salesforce for LP relationship management.
Architecture Diagram

Founder Dashboard ──→ Pipeline Service ──→ Cache (Redis) ──→ Finta API
                           ↓                                  /investors
                      Queue (Bull) ──→ Email Sync Worker      /rounds
                           ↓                                  /deal-rooms
                      Doc Room Service ──→ Finta Deal Rooms   /documents
                           ↓
                      Zapier Webhooks ──→ Slack / Sheets / CRM

Service Layer

class FundraiseService {
  constructor(private finta: FintaClient, private cache: CacheLayer) {}

  async getPipelineSnapshot(roundId: string): Promise<PipelineSnapshot> {
    const investors = await this.cache.getOrFetch(`round:${roundId}:investors`,
      () => this.finta.getInvestorsByRound(roundId));
    return { total: investors.length, byStage: this.groupByStage(investors),
             committed: investors.filter(i => i.stage === 'committed').reduce((s, i) => s + i.amount, 0) };
  }

  async moveInvestor(investorId: string, toStage: string): Promise<void> {
    await this.finta.updateInvestor(investorId, { stage: toStage });
    await this.cache.invalidate(`investor:${investorId}`);
    await this.queue.add('stage-change', { investorId, toStage, timestamp: Date.now() });
  }
}

Caching Strategy

const CACHE_CONFIG = {
  rounds:     { ttl: 600, prefix: 'round' },     // 10 min — round terms rarely change mid-raise
  investors:  { ttl: 120, prefix: 'investor' },   // 2 min — stage changes need freshness
  documents:  { ttl: 300, prefix: 'doc' },         // 5 min — doc list stable between uploads
  dealRooms:  { ttl: 60,  prefix: 'room' },        // 1 min — view analytics need near-real-time
  metrics:    { ttl: 30,  prefix: 'metric' },      // 30s — commitment totals are time-sensitive
};
// Stage-change webhooks flush investor cache immediately for dashboard accuracy

Event Pipeline

class FundraiseEventPipeline {
  private queue = new Bull('finta-events', { redis: process.env.REDIS_URL });

  async onStageChange(event: StageChangeEvent): Promise<void> {
    await this.queue.add('notify', event, { attempts: 3, backoff: { type: 'exponential', delay: 2000 } });

                

              

                
                  
                  
                  finta-sdk-patterns
                  SKILL.md
                  View full skill →
                
                
                  Integration patterns for Finta fundraising CRM with email and calendar APIs.
                  
                      ReadWriteEdit
                    
                
                
                  Finta SDK Patterns
Overview
Finta does not expose a public REST API. Integrate via: (1) CSV export + Python processing, (2) email integrations (Gmail/Outlook), (3) Zapier/Make webhooks, or (4) Stripe/payment integrations for capital collection.
CSV-Based Pipeline Tracker

import pandas as pd
from pathlib import Path

class FintaPipelineTracker:
    def __init__(self, export_path: str):
        self.df = pd.read_csv(export_path)

    def investors_by_stage(self) -> dict:
        return self.df.groupby("Stage")["Name"].apply(list).to_dict()

    def conversion_funnel(self) -> list[dict]:
        stages = self.df["Stage"].value_counts()
        return [{"stage": s, "count": c} for s, c in stages.items()]

    def overdue_followups(self, days: int = 7) -> pd.DataFrame:
        self.df["Last Contact"] = pd.to_datetime(self.df["Last Contact"])
        cutoff = pd.Timestamp.now() - pd.Timedelta(days=days)
        return self.df[
            (self.df["Stage"].isin(["Follow-up", "Due Diligence"]))
            & (self.df["Last Contact"] < cutoff)
        ]

    def total_committed(self) -> float:
        closed = self.df[self.df["Stage"] == "Closed"]
        return closed["Check Size"].sum()

Gmail Integration for Investor Tracking

# Track investor email responses via Gmail API
from googleapiclient.discovery import build

def get_investor_emails(service, investor_email: str, after_date: str):
    query = f"from:{investor_email} after:{after_date}"
    results = service.users().messages().list(
        userId="me", q=query
    ).execute()
    return results.get("messages", [])

Zapier/Make Webhook Pattern
Finta supports Zapier triggers for pipeline stage changes:

Create a Zap with "Finta - Pipeline Stage Changed" trigger
Connect to your destination (Slack, Sheets, CRM)
Map fields: investor name, new stage, deal amount

Resources

Finta Website
Finta Integrations

Next Steps
Apply in finta-core-workflow-a for fundraise pipeline management.
                
              

                
                  
                  
                  finta-security-basics
                  SKILL.md
                  View full skill →
                
                
                  Secure Finta fundraising data and investor information.
                  
                      ReadGrep
                    
                
                
                  Finta Security Basics
Overview
Finta manages fundraising pipelines containing investor contact information, term sheet details, valuation data, cap table snapshots, and deal room documents. A breach exposes confidential fundraising strategy, investor relationships, and financial terms that could damage competitive positioning. Protect API credentials, deal room access controls, and any integration that syncs investor data to external CRMs or spreadsheets.
API Key Management

function createFintaClient(): { apiKey: string; baseUrl: string } {
  const apiKey = process.env.FINTA_API_KEY;
  if (!apiKey) {
    throw new Error("Missing FINTA_API_KEY — store in secrets manager, never in code");
  }
  // Finta keys access investor contacts and financial terms — treat as highly sensitive
  console.log("Finta client initialized (key suffix:", apiKey.slice(-4), ")");
  return { apiKey, baseUrl: "https://api.trustfinta.com/v1" };
}

Webhook Signature Verification

import crypto from "crypto";
import { Request, Response, NextFunction } from "express";

function verifyFintaWebhook(req: Request, res: Response, next: NextFunction): void {
  const signature = req.headers["x-finta-signature"] as string;
  const secret = process.env.FINTA_WEBHOOK_SECRET!;
  const expected = crypto.createHmac("sha256", secret).update(req.body).digest("hex");
  if (!signature || !crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    res.status(401).send("Invalid signature");
    return;
  }
  next();
}

Input Validation

import { z } from "zod";

const InvestorContactSchema = z.object({
  investor_id: z.string().uuid(),
  firm_name: z.string().min(1).max(200),
  contact_email: z.string().email(),
  deal_stage: z.enum(["prospect", "contacted", "meeting", "term_sheet", "closed", "passed"]),
  check_size: z.number().positive().optional(),
  valuation_cap: z.number().positive().optional(),
});

function validateInvestorData(data: unknown) {
  return InvestorContactSchema.parse(data);
}

Data Protection

const FINTA_SENSITIVE_FIELDS = ["valuation_cap", "check_size", "term_sheet_url", "cap_table", "investor_email", "phone"];

function redactFintaLog(record: Record<string, unknown>): Record<string, unknown> {
  const redacted = { ...record };
  for (const field of FINTA_SENSITIVE_FIELDS) {
    if (field in redacted) redacted[field] = "[REDACTED]";
  }
  return redacted;
}

Security Checklist

[ ] API keys stored in secrets manager, not in code
[ ] Str
                
              

                
                  
                  
                  finta-upgrade-migration
                  SKILL.md
                  View full skill →
                
                
                  Handle Finta platform updates and data migration.
                  
                      ReadGrep
                    
                
                
                  Finta Upgrade & Migration
Overview
Finta is a fundraising CRM built for founders managing investor pipelines, deal rooms, and investor updates. The API exposes endpoints for funding rounds, investor contacts, and deal room documents. Tracking API changes matters because Finta evolves its data model around fundraising workflows — field renames in round stages, investor contact schema updates, and deal room permission changes can break integrations that sync pipeline data to external analytics or reporting tools.
Version Detection

const FINTA_BASE = "https://api.trustfinta.com/v1";

async function detectFintaApiVersion(apiKey: string): Promise<void> {
  const res = await fetch(`${FINTA_BASE}/rounds`, {
    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
  });
  const data = await res.json();
  const apiVersion = res.headers.get("x-finta-version") ?? "unknown";
  console.log(`Finta API version: ${apiVersion}`);

  // Check for deprecated fields in round objects
  const knownFields = ["id", "name", "stage", "target_amount", "raised_amount", "investors", "created_at"];
  if (data.rounds?.[0]) {
    const actual = Object.keys(data.rounds[0]);
    const deprecated = knownFields.filter((f) => !actual.includes(f));
    const added = actual.filter((f) => !knownFields.includes(f));
    if (deprecated.length) console.warn(`Removed fields: ${deprecated.join(", ")}`);
    if (added.length) console.log(`New fields: ${added.join(", ")}`);
  }
}

Migration Checklist

[ ] Review Finta changelog for breaking changes to round or investor endpoints
[ ] Audit codebase for hardcoded round stage values (e.g., "pre-seed", "series-a")
[ ] Verify investor contact schema — check for firm vs. organization field rename
[ ] Update deal room document upload endpoint if file size limits changed
[ ] Test investor update email delivery via API (template format may change)
[ ] Validate webhook payloads for round status change events
[ ] Migrate CSV import mappings if column headers were renamed
[ ] Check OAuth token expiry and refresh behavior for API key rotation
[ ] Update pipeline stage enum values if Finta added custom stage support
[ ] Run data export and re-import test to verify round-trip data integrity

Schema Migration

// Finta round schema evolved: flat stage string → structured stage object
interface OldRound {
  id: string;
  name: string;
  stage: string; // "pre-seed", "seed", "series-a"
  target_amount: number;
  raised_amount: number;
  investors: string[]; // investor ID

                

              

                
                  
                  
                  finta-webhooks-events
                  SKILL.md
                  View full skill →
                
                
                  Automate Finta pipeline events with Zapier and email triggers.
                  
                      ReadWriteEdit
                    
                
                
                  Finta Webhooks & Events
Overview
Finta supports event automation through its built-in automation rules and Zapier integration. Pipeline stage changes, investor replies, and deal room views can trigger external actions.
Built-in Automation Rules
Configure in Settings > Automation:

Email reply detected -> Move to next stage
Calendar meeting scheduled -> Log and notify team
Deal room viewed -> Send Slack notification
No response in X days -> Create follow-up reminder

Zapier Integration
Available triggers:

Pipeline stage changed
New investor added
Deal room accessed
Investor update sent

Example Zap: Finta stage change -> Slack message + Google Sheets row
Custom Reminder System

import pandas as pd
from datetime import datetime, timedelta

def get_followup_reminders(export_path: str, days: int = 5) -> list:
    df = pd.read_csv(export_path)
    df["Last Contact"] = pd.to_datetime(df["Last Contact"])
    cutoff = datetime.now() - timedelta(days=days)
    overdue = df[
        (df["Stage"].isin(["Reaching Out", "Follow-up"]))
        & (df["Last Contact"] < cutoff)
    ]
    return overdue[["Name", "Firm", "Email", "Last Contact", "Stage"]].to_dict("records")

Resources

Finta Website

Next Steps
For performance, see finta-performance-tuning.
                
              

          
        

      
      

      
      

      
      

      
      
  Ready to use finta-pack?
  
    
    
  




      
      
          Related Plugins
          
            
                000-jeremy-content-consistency-validator
                Read-only validator that generates comprehensive discrepancy reports comparing messaging consistency across ANY HTML-based website (WordPress, Hugo, Next.js, React, Vue, static HTML, etc.), GitHub repositories, and local documentation. Detects mixed messaging without making changes.
              
                002-jeremy-yaml-master-agent
                Intelligent YAML validation, generation, and transformation agent with schema inference, linting, and format conversion capabilities
              
                003-jeremy-vertex-ai-media-master
                Comprehensive Google Vertex AI multimodal mastery for Jeremy - video processing (6+ hours), audio generation, image creation with Gemini 2.0/2.5 and Imagen 4. Marketing campaign automation, content generation, and media asset production.
              
                004-jeremy-google-cloud-agent-sdk
                Google Cloud Agent Development Kit (ADK) and Agent Starter Pack mastery - build containerized multi-agent systems with production-ready templates, deploy to Cloud Run/GKE/Agent Engine, RAG agents, ReAct agents, and multi-agent orchestration.
              
                agent-context-manager
                Automatically detects and loads AGENTS.md files to provide agent-specific instructions
              
                ai-commit-gen
                AI-powered commit message generator - analyzes your git diff and creates conventional commit messages instantly
              
          
        

      
      
          Tags
          
            fintasaassdkintegration
          
        
    
  

  

    

    
    
        
            
                Stay in the Loop
                
                    
                    
                    
                
                No spam. Unsubscribe anytime.
            

            
                
                    Product
                    
                        Explore
                        Skills
                        Cowork
                        Compare
                        Tools
                    
                
                
                    Resources
                    
                        Docs
                        Changelog
                        Collections
                        Playbooks
                        Research
                        Learning
                    
                
                
                    Company
                    
                        Community
                        Spotlight
                        GitHub
                    
                
                
                    Legal
                    
                        Privacy
                        Terms
                        Acceptable Use
                    
                
            

            
                Tons of Skills by Intent Solutions. Marine. Citadel Grad. 20 years ops → self-taught dev → AI architect.
                © 2026 Tons of Skills | Intent Solutions

Code	Message	Cause	Fix
`400`	`Invalid round transition`	Moving round to an invalid state	Follow valid transitions: Draft > Active > Closing > Closed
`401`	`Invalid API key`	Expired or revoked `FINTAAPIKEY`	Regenerate at Settings > API Access
`404`	`Investor not found`	Deleted or merged investor record	Search by email to find merged record
`409`	`Duplicate investor`	Email already exists in pipeline	Use dedup endpoint before CSV import
`422`	`Missing required fields`	Incomplete investor or round data	Include `name`, `email`, `stage` at minimum
`429`	`Rate limit exceeded`	Too many API calls	Implement backoff; batch operations where possible
`500`	`Pipeline sync failed`	Email provider OAuth expired	Reconnect Gmail/Outlook at Settings > Integrations
`502`	`Stripe webhook failed`	Payment collection error	Verify Stripe integration and webhook URL

Issue	Cause	Solution
Emails not tracking	OAuth disconnected	Reconnect in Settings
Deal room views not logging	Browser blocking	Share via direct email
Payment link expired	Stripe session timeout	Generate new link
Aurora suggestions poor	Incomplete profile	Complete all company fields

Component	Cost Driver	Optimization
Seat licenses	Per-user/month pricing	Remove seats between fundraising rounds
Deal rooms	Each active deal room consumes quota	Archive completed deal rooms promptly
Investor pipeline syncs	API calls per investor update	Batch investor updates; sync only changed records
Payment processing	Stripe/ACH transaction fees	Consolidate payment rounds to minimize transactions
Document sharing	Storage and delivery per shared document	Deduplicate documents; use shared links over copies