No-Code & Low-Code Integrations

Connect RenderDoc to thousands of apps using our native integrations. Build automated workflows that generate PDF and Excel documents from your data.

Overview

RenderDoc provides native integrations for popular automation platforms:

• Zapier - 6,000+ apps, official integration
• Make.com - 1,500+ apps, visual workflows
• n8n - Self-hosted, community node
• SDKs - Node.js, Python & Java

---

Zapier Integration

tip

Native Integration Available - Find RenderDoc in the Zapier app directory with full OAuth 2.0 authentication.

Getting Started with Zapier

Step 1: Connect Your Account

1. Create a new Zap in Zapier
2. Search for RenderDoc in the app list
3. Click Connect and authorize your RenderDoc account via OAuth
4. Your connection is ready to use

Step 2: Choose a Trigger or Action

Select from our available triggers and actions (see tables below).

Step 3: Configure and Test

Map your data fields and test your Zap before publishing.

Available Triggers

Triggers start your Zap when an event occurs in RenderDoc:

Trigger	Description
Document Generated	When a document is successfully generated
Document Failed	When document generation fails
Batch Completed	When a batch of documents finishes processing

Available Actions

Actions let you perform operations in RenderDoc:

Action	Description
Generate PDF	Generate a PDF document from a template
Generate Excel	Generate an Excel spreadsheet from a template
Generate Batch	Generate multiple documents in one request

Available Searches

Searches let you find existing data in RenderDoc:

Search	Description
Find Document	Search for a document by job ID or status

Common Zapier Workflows

Payment Received → Generate Invoice PDF

Trigger: Stripe - Payment Succeeded Action: RenderDoc - Generate PDF

Payment successful → Generate invoice PDF → Store in Google Drive

Configuration:

1. Trigger: Stripe "Payment Intent Succeeded"
2. Action: RenderDoc "Generate PDF"
3. Select invoice template
4. Map payment data:
   • {{invoiceNumber}} → Stripe payment ID
   • {{amount}} → Payment amount
   • {{customerName}} → Customer name

Form Submission → Certificate PDF

Trigger: Google Forms / Typeform Action: RenderDoc - Generate PDF

Form submitted → Generate certificate PDF → Email to recipient

Weekly Schedule → Report Excel

Trigger: Schedule by Zapier (Weekly) Action: RenderDoc - Generate Excel

Every Monday 9 AM → Generate report → Send to stakeholders

New Customer → Welcome Document

Trigger: HubSpot - New Contact Action: RenderDoc - Generate PDF

New customer created → Generate welcome packet PDF

Trigger Data Fields

When RenderDoc triggers fire, they provide these data fields:

{
  "event": "document.generated",
  "timestamp": "2025-12-02T10:30:00Z",
  "data": {
    "jobId": "doc_abc123...",
    "templateId": "tmpl_invoice",
    "format": "pdf",
    "status": "completed",
    "downloadUrl": "https://storage.renderdoc.dev/..."
  }
}

---

Make.com Integration

tip

Native Integration Available - RenderDoc is available in the Make.com (formerly Integromat) app marketplace.

Getting Started with Make.com

Step 1: Add RenderDoc to Your Scenario

1. Create a new scenario in Make.com
2. Click the + button to add a module
3. Search for RenderDoc
4. Select a trigger or action module

Step 2: Connect Your Account

1. Click Create a connection
2. Authorize via OAuth 2.0
3. Grant requested permissions

Step 3: Configure the Module

Set up your trigger/action with the visual interface.

Available Modules

Triggers (Watch Events)

Module	Description
Watch Document Generated	Triggers when document is generated
Watch Document Failed	Triggers when generation fails
Watch Batch Completed	Triggers when batch completes

Actions

Module	Description
Generate PDF	Generate PDF from template
Generate Excel	Generate Excel from template
Generate Batch	Generate multiple documents

Searches

Module	Description
Get Document	Retrieve document by job ID

Make.com Scenario Examples

Multi-Condition Document Router

Use the Router module to generate different documents based on conditions:

Trigger → Router
           ├─→ [Order > $100] → Generate VIP Invoice
           ├─→ [First Order] → Generate Welcome PDF
           └─→ [Default] → Generate Standard Invoice

Batch Processing with Iterator

Process multiple records with intelligent rate limiting:

1. Get Records (from database/sheet)
2. Array Aggregator
3. Iterator
4. RenderDoc - Generate PDF
5. Sleep (rate limit buffer)

---

n8n Integration

tip

Community Node Available - Install n8n-nodes-renderdoc for full RenderDoc integration.

Installation

Via n8n UI:

1. Go to Settings → Community Nodes
2. Click Install a community node
3. Enter: n8n-nodes-renderdoc
4. Click Install

Via npm:

npm install n8n-nodes-renderdoc

Then restart your n8n instance.

Setting Up Credentials

Step 1: Generate API Key in RenderDoc

1. Log in to your RenderDoc dashboard at https://app.renderdoc.dev
2. Go to Settings → API Keys
3. Click Create New API Key
4. Give it a descriptive name (e.g., "n8n Integration")
5. Copy the generated API key (it will only be shown once)

Step 2: Add Credentials in n8n

1. Go to Credentials → New
2. Search for "RenderDoc API"
3. Enter your API Key
4. Optionally update the API Base URL if self-hosted
5. Click Save

Available Nodes

RenderDoc Trigger Node

Starts workflows on document events:

Event	Description
Document Generated	Document successfully created
Document Failed	Generation failed
Batch Completed	Batch processing finished

RenderDoc Action Node

Performs operations:

Operation	Description
Generate PDF	Generate PDF from template
Generate Excel	Generate Excel from template
Generate Batch	Generate multiple documents
Get Document	Get document details
Search Documents	Search document history

n8n Workflow Examples

Scheduled Report Generation

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│  Schedule   │ ──→ │  Fetch Data  │ ──→ │  Generate   │
│  (Weekly)   │     │  (Database)  │     │  Excel      │
└─────────────┘     └──────────────┘     └──────┬──────┘
                                                │
┌─────────────┐     ┌──────────────┐     ┌──────┴──────┐
│   Notify    │ ←── │  Upload to   │ ←── │  Download   │
│   (Slack)   │     │  Google Drive│     │  Document   │
└─────────────┘     └──────────────┘     └─────────────┘

Conditional Logic with Switch Node

┌──────────┐     ┌──────────┐     ┌────────────────────┐
│ Webhook  │ ──→ │  Switch  │ ──→ │ invoice → PDF      │
│          │     │  (type)  │     │ report → Excel     │
└──────────┘     └──────────┘     │ certificate → PDF  │
                                  └────────────────────┘

Self-Hosted Benefits

• Full API Access: Use all RenderDoc API endpoints
• Custom Nodes: Extend functionality as needed
• Data Privacy: Keep workflow data on your infrastructure
• Unlimited Workflows: No execution limits
• Advanced Logic: Complex branching and error handling

---

Native SDKs

info

Official SDKs - For developers who want programmatic access with full type support.

RenderDoc provides official SDKs for popular programming languages:

SDK	Package	Requirements
Node.js	@renderdoc/sdk	Node.js 18+
Python	renderdoc	Python 3.8+
Java	renderdoc-java	Java 8+

Node.js SDK

Package: @renderdoc/sdk

npm install @renderdoc/sdk

import { RenderDoc } from '@renderdoc/sdk';

const client = new RenderDoc({
  apiKey: process.env.RENDERDOC_API_KEY!,
});

// Generate a PDF document
const result = await client.documents.generate({
  templateId: 'invoice-template',
  format: 'pdf',
  variables: {
    invoiceNumber: 'INV-001',
    customerName: 'Acme Corp',
    total: 1500.00
  },
});

console.log('Download URL:', result.downloadUrl);

Batch Generation:

const result = await client.documents.generateBatch({
  templateId: 'invoice-template',
  format: 'pdf',
  documents: [
    { variables: { invoiceNumber: 'INV-001', customerName: 'Customer A' } },
    { variables: { invoiceNumber: 'INV-002', customerName: 'Customer B' } },
    { variables: { invoiceNumber: 'INV-003', customerName: 'Customer C' } },
  ],
});

console.log('Batch ID:', result.batchId);

Python SDK

Package: renderdoc

pip install renderdoc

from renderdoc import RenderDoc

client = RenderDoc(api_key="your_api_key")

# Generate a PDF document
result = client.documents.generate(
    template_id="invoice-template",
    format="pdf",
    variables={
        "invoiceNumber": "INV-001",
        "customerName": "Acme Corp",
        "total": 1500.00,
    },
)

print(f"Download URL: {result.download_url}")

Async Support:

from renderdoc import AsyncRenderDoc
import asyncio

async def main():
    async with AsyncRenderDoc(api_key="your_api_key") as client:
        result = await client.documents.generate(
            template_id="invoice-template",
            format="pdf",
            variables={"invoiceNumber": "INV-001"},
        )
        print(f"Download URL: {result.download_url}")

asyncio.run(main())

Java SDK

Package: renderdoc-java (Java 8+)

Maven

<dependency>
    <groupId>com.renderdoc</groupId>
    <artifactId>renderdoc-java</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle

implementation 'com.renderdoc:renderdoc-java:1.0.0'

Basic Usage

import com.renderdoc.RenderDoc;
import com.renderdoc.models.GenerateRequest;
import com.renderdoc.models.GenerateResult;

// Initialize client
RenderDoc client = new RenderDoc(System.getenv("RENDERDOC_API_KEY"));

// Generate a PDF document
GenerateResult result = client.documents().generate(
    GenerateRequest.builder()
        .templateId("invoice-template")
        .format("pdf")
        .variable("invoiceNumber", "INV-001")
        .variable("customerName", "Acme Corp")
        .variable("total", 1500.00)
        .build()
);

System.out.println("Download URL: " + result.getDownloadUrl());

Spring Boot Integration

@Configuration
public class RenderDocConfiguration {

    @Value("${renderdoc.api-key}")
    private String apiKey;

    @Bean
    public RenderDoc renderDoc() {
        return new RenderDoc(apiKey);
    }
}

@Service
public class DocumentService {

    private final RenderDoc renderDoc;

    public DocumentService(RenderDoc renderDoc) {
        this.renderDoc = renderDoc;
    }

    public String generateInvoice(Invoice invoice) {
        GenerateResult result = renderDoc.documents().generate(
            GenerateRequest.builder()
                .templateId("invoice-template")
                .format("pdf")
                .variable("invoiceNumber", invoice.getNumber())
                .variable("customerName", invoice.getCustomer().getName())
                .variable("total", invoice.getTotal())
                .build()
        );
        return result.getDownloadUrl();
    }
}

---

Webhook Events

All integrations can subscribe to these webhook events:

Event	Description	Data Fields
document.generated	Document created successfully	jobId, templateId, format, downloadUrl
document.failed	Document generation failed	jobId, templateId, error, errorCode
batch.completed	Batch processing finished	batchId, completedDocuments, failedDocuments

Webhook Payload Format

{
  "event": "document.generated",
  "timestamp": "2025-12-02T10:30:00.000Z",
  "data": {
    "jobId": "doc_abc123def456",
    "templateId": "tmpl_invoice",
    "format": "pdf",
    "status": "completed",
    "downloadUrl": "https://storage.renderdoc.dev/...",
    "expiresAt": "2025-12-05T10:30:00.000Z"
  }
}

Webhook Security

All webhooks include security headers for signature verification:

Header	Description
X-RenderDoc-Signature	HMAC-SHA256 signature (v1=<hex>)
X-RenderDoc-Timestamp	Unix timestamp of request
X-RenderDoc-Event-Id	Unique event identifier
X-RenderDoc-Event-Type	Event type

---

Authentication

OAuth 2.0 (Zapier & Make.com)

Zapier and Make.com use OAuth 2.0 for secure authentication.

Scopes:

Scope	Description
documents:generate	Generate documents
documents:read	Read document status
templates:read	Access templates
webhooks:read	View webhook subscriptions
webhooks:write	Manage webhook subscriptions
profile:read	Read user profile

API Keys (n8n & SDKs)

n8n and native SDKs authenticate using API keys generated in the RenderDoc dashboard.

1. Go to Settings → API Keys
2. Click Create API Key
3. Copy the key (shown only once)
4. Store securely in environment variables

# .env
RENDERDOC_API_KEY=rd_sk_xxxxxxxxxxxx

---

Rate Limits

Plan	Requests/Minute	Max Batch Size
Free	10	10
Starter	100	100
Growth	500	500
Scale	Custom	1000

warning

Use batch endpoints when generating multiple documents to avoid rate limits.

---

Best Practices

1. API Key Security

• Store keys in environment variables
• Use platform secret managers
• Rotate keys periodically
• Use separate keys for development/production

2. Error Handling

Always implement error handling:

try {
  await client.documents.generate({...});
} catch (error) {
  if (error.statusCode === 429) {
    // Rate limit - implement backoff
  } else if (error.statusCode === 400) {
    // Validation error - check request
  }
}

3. Webhook Verification

Always verify webhook signatures to prevent spoofing attacks.

4. Use Batch Endpoints

For multiple documents, use batch generation instead of individual requests:

// Bad: Many individual requests
for (const data of records) {
  await client.documents.generate({ variables: data });
}

// Good: Single batch request
await client.documents.generateBatch({
  templateId: 'invoice-template',
  format: 'pdf',
  documents: records.map(data => ({ variables: data })),
});

---

Troubleshooting

Common Issues

401 Unauthorized

• Verify API key or OAuth token is valid
• Check key has required permissions
• Ensure header is Authorization with value Bearer YOUR_API_KEY

400 Bad Request

• Validate JSON structure
• Check required fields (templateId, format)
• Verify template exists

429 Rate Limit

• Implement exponential backoff
• Use batch endpoints
• Contact support for limit increase

Webhook Not Receiving Events

• Verify URL is publicly accessible (HTTPS)
• Check subscription is active
• Review delivery logs in dashboard

Getting Help

• Documentation: https://docs.renderdoc.dev
• API Reference: https://docs.renderdoc.dev/api-reference
• Support Email: [email protected]
• Status Page: status.renderdoc.dev

---

Next Steps

• Create your first API key
• Learn about template design
• Full API documentation
• Set up webhook subscriptions