How to Integrate Pipedrive with V0

1// app/api/pipedrive/deals/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3
4const PIPEDRIVE_BASE = 'https://api.pipedrive.com/v1';
5
6async function pipedriveGet<T = unknown>(path: string, params: Record<string, string> = {}): Promise<T> {
7  const token = process.env.PIPEDRIVE_API_TOKEN;
8  if (!token) throw new Error('PIPEDRIVE_API_TOKEN is not configured');
9
10  const url = new URL(`${PIPEDRIVE_BASE}${path}`);
11  url.searchParams.set('api_token', token);
12  Object.entries(params).forEach(([key, val]) => url.searchParams.set(key, val));
13
14  const response = await fetch(url.toString(), {
15    headers: { Accept: 'application/json' },
16    next: { revalidate: 60 }, // Cache for 60 seconds
17  });
18
19  if (!response.ok) throw new Error(`Pipedrive API error: ${response.status}`);
20
21  const result = await response.json();
22  if (!result.success) throw new Error(result.error || 'Pipedrive API request failed');
23
24  return result.data;
25}
26
27interface PipedriveDeal {
28  id: number;
29  title: string;
30  value: number;
31  currency: string;
32  status: string;
33  stage_id: number;
34  stage_order_nr: number;
35  probability: number | null;
36  expected_close_date: string | null;
37  person_name: string | null;
38  org_name: string | null;
39  owner_name: string;
40  add_time: string;
41  update_time: string;
42  activities_count: number;
43  last_activity_date: string | null;
44}
45
46export async function GET(request: NextRequest) {
47  try {
48    const { searchParams } = new URL(request.url);
49    const pipelineId = searchParams.get('pipelineId') || '';
50    const userId = searchParams.get('userId') || '';
51    const status = searchParams.get('status') || 'open';
52
53    const params: Record<string, string> = { status, limit: '500' };
54    if (pipelineId) params.pipeline_id = pipelineId;
55    if (userId) params.user_id = userId;
56
57    const deals = await pipedriveGet<PipedriveDeal[]>('/deals', params);
58
59    // Group deals by stage for Kanban view
60    const dealsByStage = deals.reduce<Record<number, PipedriveDeal[]>>((acc, deal) => {
61      const stageId = deal.stage_id;
62      if (!acc[stageId]) acc[stageId] = [];
63      acc[stageId].push(deal);
64      return acc;
65    }, {});
66
67    // Calculate pipeline summary
68    const totalValue = deals.reduce((sum, d) => sum + (d.value || 0), 0);
69    const weightedValue = deals.reduce(
70      (sum, d) => sum + (d.value || 0) * ((d.probability || 0) / 100),
71      0
72    );
73
74    return NextResponse.json({
75      deals,
76      dealsByStage,
77      summary: {
78        totalDeals: deals.length,
79        totalValue,
80        weightedValue: Math.round(weightedValue),
81      },
82    });
83  } catch (error) {
84    const message = error instanceof Error ? error.message : 'Unknown error';
85    console.error('Pipedrive deals fetch failed:', message);
86    return NextResponse.json({ error: message }, { status: 500 });
87  }
88}

1// app/api/pipedrive/create-deal/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3
4const PIPEDRIVE_BASE = 'https://api.pipedrive.com/v1';
5
6function pipedriveUrl(path: string): string {
7  const url = new URL(`${PIPEDRIVE_BASE}${path}`);
8  url.searchParams.set('api_token', process.env.PIPEDRIVE_API_TOKEN!);
9  return url.toString();
10}
11
12async function pipedrivePost<T>(path: string, body: Record<string, unknown>): Promise<T> {
13  const response = await fetch(pipedriveUrl(path), {
14    method: 'POST',
15    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
16    body: JSON.stringify(body),
17  });
18  const result = await response.json();
19  if (!result.success) throw new Error(result.error || 'Pipedrive request failed');
20  return result.data;
21}
22
23interface CreateDealRequest {
24  title: string;
25  contactName: string;
26  contactEmail: string;
27  companyName?: string;
28  value?: number;
29  currency?: string;
30  stageId?: number;
31  expectedCloseDate?: string;
32  source?: string;
33}
34
35export async function POST(request: NextRequest) {
36  try {
37    const body: CreateDealRequest = await request.json();
38    const { title, contactName, contactEmail, companyName, value, currency, stageId, source } = body;
39
40    if (!title || !contactName || !contactEmail) {
41      return NextResponse.json({ error: 'title, contactName, and contactEmail are required' }, { status: 400 });
42    }
43
44    // Step 1: Create or find organization
45    let orgId: number | undefined;
46    if (companyName) {
47      const org = await pipedrivePost<{ id: number }>('/organizations', { name: companyName });
48      orgId = org.id;
49    }
50
51    // Step 2: Create person (contact)
52    const person = await pipedrivePost<{ id: number }>('/persons', {
53      name: contactName,
54      email: [{ value: contactEmail, primary: true }],
55      org_id: orgId,
56    });
57
58    // Step 3: Create the deal linked to person and org
59    const deal = await pipedrivePost<{ id: number; title: string }>('/deals', {
60      title,
61      person_id: person.id,
62      org_id: orgId,
63      value: value || 0,
64      currency: currency || 'USD',
65      stage_id: stageId || process.env.PIPEDRIVE_DEFAULT_STAGE_ID,
66    });
67
68    // Step 4: Add a note with source context
69    if (source) {
70      await pipedrivePost('/notes', {
71        content: `Lead source: ${source}`,
72        deal_id: deal.id,
73      });
74    }
75
76    return NextResponse.json({
77      success: true,
78      deal: { id: deal.id, title: deal.title },
79      person: { id: person.id },
80    });
81  } catch (error) {
82    const message = error instanceof Error ? error.message : 'Unknown error';
83    console.error('Pipedrive deal creation failed:', message);
84    return NextResponse.json({ error: message }, { status: 500 });
85  }
86}