0
# Core Resources
1

2
Core resources are the fundamental building blocks of Stripe's payment processing system. These resources are directly accessible on the main Stripe instance and handle payment processing, customer management, and basic business operations.
3

4
## Payment Processing
5

6
### PaymentIntents
7

8
Primary resource for accepting payments with support for complex payment flows:
9

10
```typescript { .api }
11
interface PaymentIntent {
12
  id: string;
13
  object: 'payment_intent';
14
  amount: number;
15
  currency: string;
16
  status: 'requires_payment_method' | 'requires_confirmation' | 'requires_action' | 'processing' | 'requires_capture' | 'canceled' | 'succeeded';
17
  customer?: string;
18
  payment_method?: string;
19
  confirmation_method: 'automatic' | 'manual';
20
  capture_method: 'automatic' | 'manual';
21
}
22

23
// Create payment intent
24
const paymentIntent = await stripe.paymentIntents.create({
25
  amount: 2000,
26
  currency: 'usd',
27
  customer: 'cus_123',
28
  payment_method_types: ['card', 'us_bank_account'],
29
  confirmation_method: 'automatic',
30
  capture_method: 'automatic'
31
});
32

33
// Retrieve payment intent
34
const retrieved = await stripe.paymentIntents.retrieve('pi_123', {
35
  expand: ['customer', 'payment_method']
36
});
37

38
// Update payment intent
39
const updated = await stripe.paymentIntents.update('pi_123', {
40
  description: 'Updated payment description',
41
  metadata: { order_id: '12345' }
42
});
43

44
// List payment intents
45
const paymentIntents = await stripe.paymentIntents.list({
46
  limit: 10,
47
  customer: 'cus_123'
48
});
49

50
// Confirm payment intent
51
const confirmed = await stripe.paymentIntents.confirm('pi_123', {
52
  payment_method: 'pm_card_visa',
53
  return_url: 'https://example.com/return'
54
});
55

56
// Cancel payment intent
57
const canceled = await stripe.paymentIntents.cancel('pi_123', {
58
  cancellation_reason: 'requested_by_customer'
59
});
60

61
// Capture payment intent (for manual capture)
62
const captured = await stripe.paymentIntents.capture('pi_123', {
63
  amount_to_capture: 1500
64
});
65

66
// Apply customer balance
67
const applied = await stripe.paymentIntents.applyCustomerBalance('pi_123', {
68
  amount: 500,
69
  currency: 'usd'
70
});
71

72
// Increment authorization
73
const incremented = await stripe.paymentIntents.incrementAuthorization('pi_123', {
74
  amount: 500
75
});
76

77
// Verify microdeposits
78
const verified = await stripe.paymentIntents.verifyMicrodeposits('pi_123', {
79
  amounts: [32, 45]
80
});
81

82
// Search payment intents
83
const searchResults = await stripe.paymentIntents.search({
84
  query: 'status:"succeeded" AND metadata["order_id"]:"12345"'
85
});
86
```
87

88
### PaymentMethods
89

90
Represents a customer's payment instruments:
91

92
```typescript { .api }
93
interface PaymentMethod {
94
  id: string;
95
  object: 'payment_method';
96
  type: 'card' | 'us_bank_account' | 'sepa_debit' | 'ideal' | string;
97
  customer?: string;
98
  card?: {
99
    brand: string;
100
    last4: string;
101
    exp_month: number;
102
    exp_year: number;
103
  };
104
}
105

106
// Create payment method
107
const paymentMethod = await stripe.paymentMethods.create({
108
  type: 'card',
109
  card: {
110
    number: '4242424242424242',
111
    exp_month: 12,
112
    exp_year: 2025,
113
    cvc: '123'
114
  },
115
  billing_details: {
116
    name: 'John Doe',
117
    email: 'john.doe@example.com'
118
  }
119
});
120

121
// Retrieve payment method
122
const retrieved = await stripe.paymentMethods.retrieve('pm_123');
123

124
// Update payment method
125
const updated = await stripe.paymentMethods.update('pm_123', {
126
  billing_details: {
127
    name: 'Jane Doe'
128
  }
129
});
130

131
// List payment methods
132
const paymentMethods = await stripe.paymentMethods.list({
133
  customer: 'cus_123',
134
  type: 'card'
135
});
136

137
// Attach to customer
138
const attached = await stripe.paymentMethods.attach('pm_123', {
139
  customer: 'cus_123'
140
});
141

142
// Detach from customer
143
const detached = await stripe.paymentMethods.detach('pm_123');
144
```
145

146
### Charges
147

148
Represents completed payments:
149

150
```typescript { .api }
151
interface Charge {
152
  id: string;
153
  object: 'charge';
154
  amount: number;
155
  currency: string;
156
  status: 'pending' | 'succeeded' | 'failed';
157
  customer?: string;
158
  payment_intent?: string;
159
  captured: boolean;
160
  refunded: boolean;
161
}
162

163
// Create charge (legacy, use PaymentIntents instead)
164
const charge = await stripe.charges.create({
165
  amount: 2000,
166
  currency: 'usd',
167
  source: 'tok_visa',
168
  description: 'My First Test Charge'
169
});
170

171
// Retrieve charge
172
const retrieved = await stripe.charges.retrieve('ch_123');
173

174
// Update charge
175
const updated = await stripe.charges.update('ch_123', {
176
  description: 'Updated charge description',
177
  metadata: { order_id: '12345' }
178
});
179

180
// List charges
181
const charges = await stripe.charges.list({
182
  limit: 10,
183
  customer: 'cus_123'
184
});
185

186
// Capture charge (for manual capture)
187
const captured = await stripe.charges.capture('ch_123', {
188
  amount: 1500
189
});
190

191
// Search charges
192
const searchResults = await stripe.charges.search({
193
  query: 'amount>999 AND metadata["order_id"]:"12345"'
194
});
195
```
196

197
## Customer Management
198

199
### Customers
200

201
Central resource for managing customer information and relationships:
202

203
```typescript { .api }
204
interface Customer {
205
  id: string;
206
  object: 'customer';
207
  email?: string;
208
  name?: string;
209
  phone?: string;
210
  default_source?: string;
211
  invoice_prefix?: string;
212
  balance: number;
213
  created: number;
214
}
215

216
// Create customer
217
const customer = await stripe.customers.create({
218
  email: 'customer@example.com',
219
  name: 'John Doe',
220
  phone: '+1234567890',
221
  description: 'My first test customer',
222
  payment_method: 'pm_card_visa',
223
  invoice_settings: {
224
    default_payment_method: 'pm_card_visa'
225
  }
226
});
227

228
// Retrieve customer
229
const retrieved = await stripe.customers.retrieve('cus_123', {
230
  expand: ['default_source']
231
});
232

233
// Update customer
234
const updated = await stripe.customers.update('cus_123', {
235
  email: 'newemail@example.com',
236
  metadata: { user_id: '12345' }
237
});
238

239
// List customers
240
const customers = await stripe.customers.list({
241
  limit: 10,
242
  created: { gte: Math.floor(Date.now() / 1000) - 86400 }
243
});
244

245
// Delete customer
246
const deleted = await stripe.customers.del('cus_123');
247

248
// Search customers
249
const searchResults = await stripe.customers.search({
250
  query: 'email:"test@example.com" OR metadata["user_id"]:"12345"'
251
});
252
```
253

254
### Customer Sub-resources
255

256
Manage customer-specific data:
257

258
```typescript { .api }
259
// Customer balance transactions
260
const balanceTransaction = await stripe.customers.createBalanceTransaction(
261
  'cus_123',
262
  {
263
    amount: -1000,
264
    currency: 'usd',
265
    description: 'Store credit refund'
266
  }
267
);
268

269
const balanceTransactions = await stripe.customers.listBalanceTransactions('cus_123');
270

271
// Customer cash balance
272
const cashBalance = await stripe.customers.retrieveCashBalance('cus_123');
273

274
const updatedCashBalance = await stripe.customers.updateCashBalance('cus_123', {
275
  settings: {
276
    reconciliation_mode: 'automatic'
277
  }
278
});
279

280
// Customer payment methods
281
const paymentMethods = await stripe.customers.listPaymentMethods('cus_123', {
282
  type: 'card'
283
});
284

285
const paymentMethod = await stripe.customers.retrievePaymentMethod(
286
  'cus_123',
287
  'pm_123'
288
);
289

290
// Customer sources (legacy)
291
const source = await stripe.customers.createSource('cus_123', {
292
  source: 'tok_visa'
293
});
294

295
const sources = await stripe.customers.listSources('cus_123', {
296
  object: 'card'
297
});
298

299
// Customer tax IDs
300
const taxId = await stripe.customers.createTaxId('cus_123', {
301
  type: 'us_ein',
302
  value: '12-3456789'
303
});
304

305
const taxIds = await stripe.customers.listTaxIds('cus_123');
306

307
// Funding instructions
308
const fundingInstructions = await stripe.customers.createFundingInstructions(
309
  'cus_123',
310
  {
311
    bank_transfer: {
312
      requested_address_types: ['aba'],
313
      type: 'us_bank_transfer'
314
    },
315
    currency: 'usd',
316
    funding_type: 'bank_transfer'
317
  }
318
);
319
```
320

321
## Product and Pricing
322

323
### Products
324

325
Represents goods or services sold:
326

327
```typescript { .api }
328
interface Product {
329
  id: string;
330
  object: 'product';
331
  name: string;
332
  description?: string;
333
  type: 'good' | 'service';
334
  active: boolean;
335
  default_price?: string;
336
}
337

338
// Create product
339
const product = await stripe.products.create({
340
  name: 'Gold Special',
341
  description: 'Premium gold membership',
342
  type: 'service',
343
  default_price_data: {
344
    currency: 'usd',
345
    unit_amount: 2000,
346
    recurring: {
347
      interval: 'month'
348
    }
349
  }
350
});
351

352
// Retrieve product
353
const retrieved = await stripe.products.retrieve('prod_123');
354

355
// Update product
356
const updated = await stripe.products.update('prod_123', {
357
  name: 'Platinum Special',
358
  description: 'Updated premium membership'
359
});
360

361
// List products
362
const products = await stripe.products.list({
363
  limit: 10,
364
  active: true
365
});
366

367
// Delete product
368
const deleted = await stripe.products.del('prod_123');
369

370
// Search products
371
const searchResults = await stripe.products.search({
372
  query: 'name:"gold" AND active:"true"'
373
});
374
```
375

376
### Prices
377

378
Defines pricing information for products:
379

380
```typescript { .api }
381
interface Price {
382
  id: string;
383
  object: 'price';
384
  product: string;
385
  unit_amount?: number;
386
  currency: string;
387
  type: 'one_time' | 'recurring';
388
  recurring?: {
389
    interval: 'day' | 'week' | 'month' | 'year';
390
    interval_count: number;
391
  };
392
}
393

394
// Create price
395
const price = await stripe.prices.create({
396
  product: 'prod_123',
397
  unit_amount: 2000,
398
  currency: 'usd',
399
  recurring: {
400
    interval: 'month'
401
  }
402
});
403

404
// Create tiered pricing
405
const tieredPrice = await stripe.prices.create({
406
  product: 'prod_123',
407
  currency: 'usd',
408
  billing_scheme: 'tiered',
409
  tiers_mode: 'volume',
410
  tiers: [
411
    { up_to: 10, unit_amount: 1000 },
412
    { up_to: 'inf', unit_amount: 800 }
413
  ],
414
  recurring: {
415
    interval: 'month'
416
  }
417
});
418

419
// Retrieve price
420
const retrieved = await stripe.prices.retrieve('price_123');
421

422
// Update price
423
const updated = await stripe.prices.update('price_123', {
424
  nickname: 'Monthly Gold Plan',
425
  metadata: { plan_type: 'premium' }
426
});
427

428
// List prices
429
const prices = await stripe.prices.list({
430
  limit: 10,
431
  product: 'prod_123',
432
  active: true
433
});
434

435
// Search prices
436
const searchResults = await stripe.prices.search({
437
  query: 'currency:"usd" AND type:"recurring"'
438
});
439
```
440

441
## Account Management
442

443
### Accounts
444

445
Manage Connect accounts:
446

447
```typescript { .api }
448
interface Account {
449
  id: string;
450
  object: 'account';
451
  type: 'standard' | 'express' | 'custom';
452
  country: string;
453
  email?: string;
454
  default_currency: string;
455
  charges_enabled: boolean;
456
  payouts_enabled: boolean;
457
}
458

459
// Create account
460
const account = await stripe.accounts.create({
461
  type: 'express',
462
  country: 'US',
463
  email: 'merchant@example.com',
464
  capabilities: {
465
    card_payments: { requested: true },
466
    transfers: { requested: true }
467
  }
468
});
469

470
// Retrieve account (omit ID for own account)
471
const retrieved = await stripe.accounts.retrieve('acct_123');
472
const ownAccount = await stripe.accounts.retrieve();
473

474
// Update account
475
const updated = await stripe.accounts.update('acct_123', {
476
  business_profile: {
477
    name: 'Updated Business Name',
478
    url: 'https://example.com'
479
  }
480
});
481

482
// List accounts
483
const accounts = await stripe.accounts.list({
484
  limit: 10
485
});
486

487
// Delete account
488
const deleted = await stripe.accounts.del('acct_123');
489

490
// Reject account
491
const rejected = await stripe.accounts.reject('acct_123', {
492
  reason: 'fraud'
493
});
494
```
495

496
### Account Sub-resources
497

498
```typescript { .api }
499
// External accounts (bank accounts/cards for payouts)
500
const externalAccount = await stripe.accounts.createExternalAccount(
501
  'acct_123',
502
  {
503
    external_account: 'btok_123'
504
  }
505
);
506

507
const externalAccounts = await stripe.accounts.listExternalAccounts('acct_123');
508

509
// Persons (for custom accounts)
510
const person = await stripe.accounts.createPerson('acct_123', {
511
  first_name: 'John',
512
  last_name: 'Doe',
513
  email: 'john.doe@example.com',
514
  relationship: {
515
    representative: true,
516
    owner: true,
517
    percent_ownership: 100
518
  }
519
});
520

521
const persons = await stripe.accounts.listPersons('acct_123');
522

523
// Capabilities
524
const capabilities = await stripe.accounts.listCapabilities('acct_123');
525

526
const capability = await stripe.accounts.updateCapability(
527
  'acct_123',
528
  'card_payments',
529
  { requested: true }
530
);
531

532
// Login links (for Express accounts)
533
const loginLink = await stripe.accounts.createLoginLink('acct_123', {
534
  redirect_url: 'https://example.com/dashboard'
535
});
536
```
537

538
## File Management
539

540
### Files
541

542
Handle file uploads for identity verification and disputes:
543

544
```typescript { .api }
545
interface File {
546
  id: string;
547
  object: 'file';
548
  filename?: string;
549
  purpose: 'account_requirement' | 'additional_verification' | 'business_icon' | 'business_logo' | 'customer_signature' | 'dispute_evidence' | 'document_provider_identity_document' | 'finance_report_run' | 'identity_document' | 'pci_document' | 'sigma_scheduled_query' | 'tax_document_user_upload';
550
  size: number;
551
  type?: string;
552
  url?: string;
553
}
554

555
// Upload file
556
const file = await stripe.files.create({
557
  file: {
558
    data: fs.readFileSync('path/to/file.pdf'),
559
    name: 'file.pdf',
560
    type: 'application/pdf'
561
  },
562
  purpose: 'dispute_evidence'
563
});
564

565
// Retrieve file
566
const retrieved = await stripe.files.retrieve('file_123');
567

568
// List files
569
const files = await stripe.files.list({
570
  limit: 10,
571
  purpose: 'dispute_evidence'
572
});
573
```
574

575
### FileLinks
576

577
Create temporary links to files:
578

579
```typescript { .api }
580
interface FileLink {
581
  id: string;
582
  object: 'file_link';
583
  file: string;
584
  url: string;
585
  expires_at?: number;
586
}
587

588
// Create file link
589
const fileLink = await stripe.fileLinks.create({
590
  file: 'file_123',
591
  expires_at: Math.floor(Date.now() / 1000) + 3600 // 1 hour
592
});
593

594
// Retrieve file link
595
const retrieved = await stripe.fileLinks.retrieve('link_123');
596

597
// Update file link
598
const updated = await stripe.fileLinks.update('link_123', {
599
  metadata: { purpose: 'customer_download' }
600
});
601

602
// List file links
603
const fileLinks = await stripe.fileLinks.list({
604
  limit: 10
605
});
606
```
607

608
## Balance and Transactions
609

610
### Balance
611

612
Check account balance:
613

614
```typescript { .api }
615
interface Balance {
616
  object: 'balance';
617
  available: Array<{
618
    amount: number;
619
    currency: string;
620
    source_types?: {
621
      [key: string]: number;
622
    };
623
  }>;
624
  pending: Array<{
625
    amount: number;
626
    currency: string;
627
    source_types?: {
628
      [key: string]: number;
629
    };
630
  }>;
631
}
632

633
// Retrieve balance
634
const balance = await stripe.balance.retrieve();
635
```
636

637
### BalanceTransactions
638

639
History of balance changes:
640

641
```typescript { .api }
642
interface BalanceTransaction {
643
  id: string;
644
  object: 'balance_transaction';
645
  amount: number;
646
  currency: string;
647
  description?: string;
648
  fee: number;
649
  fee_details: Array<{
650
    amount: number;
651
    currency: string;
652
    description: string;
653
    type: string;
654
  }>;
655
  net: number;
656
  status: 'available' | 'pending';
657
  type: string;
658
}
659

660
// Retrieve balance transaction
661
const transaction = await stripe.balanceTransactions.retrieve('txn_123');
662

663
// List balance transactions
664
const transactions = await stripe.balanceTransactions.list({
665
  limit: 10,
666
  type: 'charge'
667
});
668
```
669

670
## Disputes and Refunds
671

672
### Disputes
673

674
Handle payment disputes:
675

676
```typescript { .api }
677
interface Dispute {
678
  id: string;
679
  object: 'dispute';
680
  amount: number;
681
  currency: string;
682
  charge: string;
683
  status: 'warning_needs_response' | 'warning_under_review' | 'warning_closed' | 'needs_response' | 'under_review' | 'charge_refunded' | 'won' | 'lost';
684
  reason: string;
685
}
686

687
// Retrieve dispute
688
const dispute = await stripe.disputes.retrieve('dp_123');
689

690
// Update dispute
691
const updated = await stripe.disputes.update('dp_123', {
692
  evidence: {
693
    customer_communication: 'file_123',
694
    receipt: 'file_456'
695
  }
696
});
697

698
// List disputes
699
const disputes = await stripe.disputes.list({
700
  limit: 10,
701
  charge: 'ch_123'
702
});
703

704
// Close dispute
705
const closed = await stripe.disputes.close('dp_123');
706
```
707

708
### Refunds
709

710
Process refunds:
711

712
```typescript { .api }
713
interface Refund {
714
  id: string;
715
  object: 'refund';
716
  amount: number;
717
  currency: string;
718
  charge?: string;
719
  payment_intent?: string;
720
  status: 'pending' | 'succeeded' | 'failed' | 'canceled';
721
  reason?: 'duplicate' | 'fraudulent' | 'requested_by_customer';
722
}
723

724
// Create refund
725
const refund = await stripe.refunds.create({
726
  charge: 'ch_123',
727
  amount: 1000,
728
  reason: 'requested_by_customer'
729
});
730

731
// Retrieve refund
732
const retrieved = await stripe.refunds.retrieve('re_123');
733

734
// Update refund
735
const updated = await stripe.refunds.update('re_123', {
736
  metadata: { reason: 'defective_product' }
737
});
738

739
// List refunds
740
const refunds = await stripe.refunds.list({
741
  limit: 10,
742
  charge: 'ch_123'
743
});
744

745
// Cancel refund
746
const canceled = await stripe.refunds.cancel('re_123');
747
```
748

749
## Transfers
750

751
Move money between accounts:
752

753
```typescript { .api }
754
interface Transfer {
755
  id: string;
756
  object: 'transfer';
757
  amount: number;
758
  currency: string;
759
  destination: string;
760
  source_type: string;
761
  status: string;
762
}
763

764
// Create transfer
765
const transfer = await stripe.transfers.create({
766
  amount: 1000,
767
  currency: 'usd',
768
  destination: 'acct_123'
769
});
770

771
// Retrieve transfer
772
const retrieved = await stripe.transfers.retrieve('tr_123');
773

774
// Update transfer
775
const updated = await stripe.transfers.update('tr_123', {
776
  metadata: { order_id: '12345' }
777
});
778

779
// List transfers
780
const transfers = await stripe.transfers.list({
781
  limit: 10,
782
  destination: 'acct_123'
783
});
784

785
// Create transfer reversal
786
const reversal = await stripe.transfers.createReversal('tr_123', {
787
  amount: 500
788
});
789

790
// List transfer reversals
791
const reversals = await stripe.transfers.listReversals('tr_123');
792
```
793

794
### SetupIntents
795

796
Handles setting up payment methods for future use without immediate payment:
797

798
```typescript { .api }
799
interface SetupIntent {
800
  id: string;
801
  object: 'setup_intent';
802
  client_secret: string;
803
  customer?: string;
804
  payment_method?: string;
805
  status: 'requires_payment_method' | 'requires_confirmation' | 'requires_action' | 'processing' | 'canceled' | 'succeeded';
806
  usage: 'off_session' | 'on_session';
807
  payment_method_types: Array<string>;
808
  next_action?: {
809
    type: string;
810
    use_stripe_sdk?: Record<string, any>;
811
  };
812
}
813

814
// Create setup intent
815
const setupIntent = await stripe.setupIntents.create({
816
  customer: 'cus_123',
817
  payment_method_types: ['card'],
818
  usage: 'off_session'
819
});
820

821
// Create with automatic payment methods
822
const autoSetupIntent = await stripe.setupIntents.create({
823
  customer: 'cus_123',
824
  automatic_payment_methods: {
825
    enabled: true
826
  },
827
  usage: 'off_session'
828
});
829

830
// Retrieve setup intent
831
const retrieved = await stripe.setupIntents.retrieve('seti_123', {
832
  expand: ['payment_method']
833
});
834

835
// Update setup intent
836
const updated = await stripe.setupIntents.update('seti_123', {
837
  metadata: { order_id: '12345' }
838
});
839

840
// Confirm setup intent
841
const confirmed = await stripe.setupIntents.confirm('seti_123', {
842
  payment_method: 'pm_card_visa',
843
  return_url: 'https://your-website.com/return'
844
});
845

846
// List setup intents
847
const setupIntents = await stripe.setupIntents.list({
848
  customer: 'cus_123',
849
  limit: 10
850
});
851

852
// Cancel setup intent
853
const canceled = await stripe.setupIntents.cancel('seti_123');
854
```
855

856
### PaymentLinks
857

858
Create shareable payment links for no-code payments:
859

860
```typescript { .api }
861
interface PaymentLink {
862
  id: string;
863
  object: 'payment_link';
864
  url: string;
865
  active: boolean;
866
  line_items: {
867
    data: Array<{
868
      id: string;
869
      price: string;
870
      quantity: number;
871
    }>;
872
  };
873
  payment_method_types: Array<string>;
874
  shipping_address_collection?: {
875
    allowed_countries: Array<string>;
876
  };
877
}
878

879
// Create payment link
880
const paymentLink = await stripe.paymentLinks.create({
881
  line_items: [
882
    {
883
      price: 'price_123',
884
      quantity: 1
885
    }
886
  ],
887
  payment_method_types: ['card']
888
});
889

890
// Create with shipping
891
const shippingLink = await stripe.paymentLinks.create({
892
  line_items: [
893
    {
894
      price: 'price_123',
895
      quantity: 1
896
    }
897
  ],
898
  shipping_address_collection: {
899
    allowed_countries: ['US', 'CA']
900
  }
901
});
902

903
// Retrieve payment link
904
const retrieved = await stripe.paymentLinks.retrieve('plink_123');
905

906
// Update payment link
907
const updated = await stripe.paymentLinks.update('plink_123', {
908
  active: false,
909
  metadata: { campaign: 'summer_sale' }
910
});
911

912
// List payment links
913
const paymentLinks = await stripe.paymentLinks.list({
914
  active: true,
915
  limit: 10
916
});
917

918
// List line items
919
const lineItems = await stripe.paymentLinks.listLineItems('plink_123');
920
```
921

922
### Quotes
923

924
Create and manage quotes for B2B workflows:
925

926
```typescript { .api }
927
interface Quote {
928
  id: string;
929
  object: 'quote';
930
  status: 'draft' | 'open' | 'accepted' | 'canceled';
931
  customer: string;
932
  line_items: {
933
    data: Array<{
934
      id: string;
935
      price: string;
936
      quantity: number;
937
    }>;
938
  };
939
  amount_total: number;
940
  currency: string;
941
  expires_at: number;
942
}
943

944
// Create quote
945
const quote = await stripe.quotes.create({
946
  customer: 'cus_123',
947
  line_items: [
948
    {
949
      price: 'price_123',
950
      quantity: 2
951
    }
952
  ],
953
  collection_method: 'send_invoice'
954
});
955

956
// Create with subscription
957
const subscriptionQuote = await stripe.quotes.create({
958
  customer: 'cus_123',
959
  line_items: [
960
    {
961
      price: 'price_123',
962
      quantity: 1
963
    }
964
  ],
965
  subscription_data: {
966
    trial_period_days: 14
967
  }
968
});
969

970
// Retrieve quote
971
const retrieved = await stripe.quotes.retrieve('qt_123');
972

973
// Update quote
974
const updated = await stripe.quotes.update('qt_123', {
975
  metadata: { department: 'sales' }
976
});
977

978
// Finalize quote
979
const finalized = await stripe.quotes.finalizeQuote('qt_123');
980

981
// Accept quote
982
const accepted = await stripe.quotes.accept('qt_123');
983

984
// Cancel quote
985
const canceled = await stripe.quotes.cancel('qt_123');
986

987
// List quotes
988
const quotes = await stripe.quotes.list({
989
  customer: 'cus_123',
990
  status: 'open'
991
});
992

993
// List line items
994
const lineItems = await stripe.quotes.listLineItems('qt_123');
995

996
// List computed upfront line items
997
const upfrontItems = await stripe.quotes.listComputedUpfrontLineItems('qt_123');
998
```
999

1000
These core resources provide the foundation for all Stripe integrations, handling the essential payment processing, customer management, and business operations that most applications require.