# Decision guide: Invoice delivery
> Choose the optimal invoice delivery strategy for your integration with interactive decision trees. Compare Payabli native invoicing vs custom invoice solutions with embedded components or payment links
When building your integration with Payabli, you need to decide how to create, deliver, and collect payment on invoices. This guide helps you choose between using Payabli's native invoicing system or building custom invoice delivery based on your specific use case and requirements.
## Decision tree
Use this interactive decision tree to walk through the best approach for invoice delivery in your integration.
## Recommended strategy by use case
Choose the right invoice delivery approach based on your needs. Here's a quick reference to help you decide:
| **Use case** | **Recommended approach** |
| -------------------------------------------------- | ------------------------------------- |
| Standard service invoicing | Payabli native invoicing |
| Quick implementation with minimal developer effort | Payabli native invoicing |
| Recurring subscription billing | Payabli native invoicing with autopay |
| SaaS platform with existing invoices | Custom invoice + embedded components |
| Complex invoice workflows | Custom invoice + embedded components |
| Strict branding requirements | Custom invoice + embedded components |
| PDF invoice delivery via email | Custom invoice + payment link |
| Reducing PCI compliance scope | Custom invoice + payment link |
| Multi-tenant platform invoicing | Custom invoice + payment link |
## Payabli native invoicing
Payabli native invoicing is ideal when you need complete invoice management with minimal development effort. The system handles invoice creation, delivery, payment collection, and status tracking. Use native invoicing when:
* You need standard invoice functionality without custom design requirements
* You want to minimize development effort and technical overhead
* You're processing recurring invoices with autopay enrollment
* You need built-in payment tracking and reconciliation
* You want automated email delivery with payment links
Native invoicing is reliable when:
* You can use Payabli's standard invoice template
* Your customers accept email delivery with hosted payment pages
* You don't require custom invoice layout or branding
* Standard invoice workflows meet your business needs
### Implementation overview
Native invoicing requires only API integration to create and send invoices. Payabli handles all other aspects of the invoice lifecycle.
First, [create a Payabli invoice](/guides/pay-in-developer-invoices-manage#create-an-invoice).
Next, [email the invoice](/guides/pay-in-developer-invoices-manage#email-an-invoice) that contains a payment link to the customer.
Receive payment notification via the `InvoicePaid` webhook. You must configure this. See [Webhook setup](/guides/pay-ops-developer-notifications-manage).
### Key features
Understanding what Payabli native invoicing provides helps you determine if it meets your requirements.
| Feature | Description |
| ------------------ | -------------------------------------------------------------------------- |
| Invoice creation | API and UI options for creating invoices with line items, taxes, discounts |
| Automated delivery | Email and SMS options with payment links automatically included |
| Status management | Track invoice lifecycle from draft through paid with automatic updates |
| Recurring support | Set up autopay enrollment for subscription-style billing |
| Payment tracking | Dashboard visibility for all invoices and payment status |
| Hosted payment | Secure payment pages with PCI compliance handled by Payabli |
### Native invoicing best practices
Follow these best practices to build reliable native invoicing implementations.
* Set up webhooks for immediate payment notifications rather than polling invoice status
* Include detailed line items for customer clarity and proper accounting
* Set appropriate due dates and configure reminder notifications
* Enable autopay enrollment for recurring billing scenarios
* Monitor invoice status through dashboard for customer service inquiries
## Custom invoice with embedded components
Custom invoicing with embedded components is ideal when you need complete control over invoice design and want customers to pay without leaving your page. You host custom invoice pages and use the temporary token flow with Payabli embedded components to collect payment securely. Use embedded components when:
* You need complete branding control over invoice presentation
* You're building SaaS platforms with existing invoice systems
* You want customers to pay directly on your invoice page
* You have frontend and backend development resources
* You need custom invoice workflows or business logic
* You need complete control over transaction parameters
Embedded components with temporary token flow are reliable when:
* You can manage component lifecycle and error handling
* You implement proper invoice status tracking in your system
* You handle customer confirmations and receipt delivery
* You can make secure API calls from your backend
### Implementation overview
Custom invoicing with embedded components uses the temporary token flow to give you complete control while maintaining PCI compliance. This approach combines the security of embedded components with the flexibility of direct API calls.
Create your own custom webpage to host invoices with your branding and layout, with a container for the embedded component on the page.
Configure the [EmbeddedMethod UI component](/guides/pay-in-components-embeddedmethod-ui) to generate a temporary token.
```javascript
var payabliConfig = {
type: "methodEmbedded",
rootContainer: "payment-container",
defaultOpen: 'card',
token: "YOUR_API_TOKEN",
temporaryToken: true, // Generate temporary token
hideComponent: false,
// Additional styling and configuration
};
```
Capture the temporary token returned by the embedded component after customer enters payment details.
```javascript
// Component returns temporary token
response.responseData = {
"referenceId": "30e7658e-5c2c-4638-8308-b48edec0718b-1647",
"resultCode": 1,
"resultText": "Added",
"customerId": 1647
}
```
Use the temporary token (from the `referenceId` field) to make a call the MoneyIn/getpaid endpoint for the invoice amount.
```javascript
// Use temporary token to process payment
POST /api/MoneyIn/getpaid
{
"paymentMethod": {
"method": "card",
"storedMethodId": "30e7658e-5c2c-4638-8308-b48edec0718b-1647"
},
"orderId": "INV-2025-001",
"entryPoint": "invoice_payment",
"paymentDetails": {
"totalAmount": 1500.00
},
"customerData": {
"customerId": 1647
}
}
```
### Component options
Understanding which embedded component to use helps you choose the right approach for your invoice payment collection.
| Component | Use case | Key features |
| ------------------- | ---------------------- | ----------------------------------------------------------------------------------- |
| `EmbeddedMethod UI` | Inline payment form | Displays directly on page, supports all payment methods, temporary token generation |
| `PayMethod UI` | Modal payment form | Opens in modal overlay, supports all payment methods, temporary token generation |
| `ExpressMethod` | Digital wallet methods | Quick payment with Apple Pay™ or Google Pay™ methods |
### Embedded components best practices
Follow these best practices to build reliable embedded component implementations.
* Use temporary token flow for complete control over transaction parameters
* Implement proper error handling for declined payments and validation errors
* Use webhooks in addition to API responses for reliable payment confirmation
* Apply custom styling to match your invoice design and brand guidelines
* Track invoice status changes in your system for accurate reporting
* Send branded confirmation emails with transaction details to customers
* Make secure API calls from your backend, never expose API credentials in frontend
* Set up webhooks for payment notifications and status updates
## Custom invoice with payment links
Custom invoicing with payment links is ideal when you need control over invoice design with minimal technical complexity. You create custom invoices and include links that redirect customers to Payabli's hosted payment page. Use payment links when:
* You need custom invoice design without embedded component complexity
* You're delivering PDF invoices via email
* You want to minimize PCI compliance scope
* You have limited frontend development resources
* You're building email-based invoice workflows
Payment links are reliable when:
* Customer redirect to payment page provides acceptable experience
* You can manage invoice status tracking in your system
* You implement webhook handling for payment notifications
* Your invoice format supports clickable links
### Implementation overview
Custom invoicing with payment links requires invoice design capability and payment link generation.
Create custom invoice HTML or PDF with a payment button.
Generate a hosted payment page and payment link. See [Generate Payment Link](/guides/pay-in-developer-payment-links-manage) for more information.
On your custom invoice, add a payment button or link to the Payment Link with a clear call to action.
Set up the `InvoicePaid` webhook to receive payment notifications when customers complete payment via the payment link.
### Link configuration options
Understanding payment link configuration helps you create the best customer experience.
| Configuration | Description |
| --------------- | ------------------------------------------------------------- |
| Basic link | URL with invoice amount and customer information |
| Customized page | Configure appearance, logo, colors to match your branding |
| Return URL | Redirect customers back to your site after payment completion |
| Metadata | Include invoice references for tracking and reconciliation |
### Payment link best practices
Follow these best practices to build reliable payment link implementations.
* Generate unique payment links for each invoice to track payment accurately
* Configure return URLs to provide confirmation pages after payment
* Customize hosted page appearance to match your invoice branding
* Use webhooks for reliable payment notification rather than return URL only
* Include clear payment instructions and support contact in invoices
## Choosing the right approach
Selecting the appropriate invoice delivery method is crucial for meeting your business needs and providing a seamless customer experience. Consider the following factors when making your decision:
### Decision framework
Start with your requirements to determine the best approach.
**Need standard invoicing with minimal development?** Use Payabli native invoicing for complete invoice management with API-only integration.
**Need complete branding control with inline payment?** Use custom invoices with embedded components for seamless customer experience on your pages.
**Need custom design with easy implementation?** Use custom invoices with payment links for branding control without component integration complexity.
### Comparison matrix
Compare approaches across key factors to make the best decision for your integration.
| Factor | Native Invoicing | Embedded Components | Payment Links |
| -------------------- | ----------------------- | -------------------------------- | ----------------------- |
| **Design control** | Standard template | Complete control | Complete control |
| **Payment UX** | Redirect to hosted page | Inline on invoice | Redirect to hosted page |
| **Developer effort** | Minimal (API only) | Moderate (component integration) | Low (link generation) |
| **PCI scope** | None | Reduced | Minimal |
| **Branding** | Limited | Full customization | Full customization |
| **Invoice delivery** | Payabli handles | You handle | You handle |
| **Status tracking** | Automatic | You manage | You manage |
## Best practices
Follow these best practices to ensure successful invoice delivery and payment collection regardless of the approach you choose.
Follow these best practices when creating and designing invoices.
* Include all required invoice information like terms, tax details, itemization
* Make payment instructions clear with prominent calls-to-action
* Specify accepted payment methods and processing expectations
* Provide support contact information for payment questions
* Ensure mobile-responsive design for customer convenience
Follow these best practices for post-payment communication.
* Send immediate confirmation to customers after successful payment
* Include complete transaction details and payment method information
* Provide receipts with your branding for professional appearance
* Store receipts in customer accounts for future reference
* Make customer support easily accessible for questions
Follow these best practices for managing invoice status.
* Implement reliable webhook endpoints with proper error handling
* Use idempotency to handle duplicate webhook deliveries gracefully
* Update invoice status immediately when webhooks received
* Implement polling as backup for webhook delivery failures
* Maintain clear audit trail of all status changes
## Quick reference
This section provides quick links to relevant API endpoints, webhook events, and integration guides mentioned in the decision tree and throughout this guide.
**API References:**
* [Create invoice API](/developers/api-reference/invoice/add-invoice)
* [Send invoice API](/developers/api-reference/invoice/send-invoice-via-email)
* [Query invoices API](/developers/api-reference/invoice/get-list-of-invoices-for-an-entrypoint)
**Integration Guides:**
* [Invoice management guide](/guides/pay-in-developer-invoices-manage)
**Integration Guides:**
* [Temporary token flow with embedded components](/guides/platform-developer-tokenization-temp-flow)
* [EmbeddedMethod UI configuration](/guides/pay-in-components-embeddedmethod-ui)
* [PayMethod UI configuration](/guides/pay-in-components-paymethod-ui)
* [ExpressMethod component](/guides/pay-in-components-express-checkout)
* [Component integration overview](/guides/pay-in-components-overview)
**API References:**
* [Create hosted payment page](/developers/api-reference/hostedpaymentpages/create-a-payment-page)
**Integration Guides:**
* [Hosted payment page quick start](/guides/pay-in-payment-page-overview)
**Webhook Payloads:**
* [InvoicePaid webhook payload](/guides/pay-ops-webhooks-payloads#invoicepaid)
* [ApprovedPayment webhook payload](/guides/pay-ops-webhooks-payloads#approvedpayment)
**Integration Guides:**
* [Webhook setup and configuration](/guides/pay-ops-developer-notifications-manage)
**API References:**
* [Make transaction via the API](/developers/api-reference/moneyin/make-a-transaction)
**Integration Guides:**
* [Make a sale transaction](/guides/pay-in-developer-transactions-create)
* [Return codes and errors](/guides/platform-return-codes-and-errors-reference)