No-Code & Low-Code Integrations

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

Overview

Rynko 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 Rynko in the Zapier app directory with full OAuth 2.0 authentication.

Getting Started with Zapier

Step 1: Connect Your Account

Create a new Zap in Zapier
Search for Rynko in the app list
Click Connect and authorize your Rynko account via OAuth
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 Rynko:

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 Rynko:

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 Rynko:

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: Rynko - Generate PDF

Payment successful → Generate invoice PDF → Store in Google Drive

Configuration:

Trigger: Stripe "Payment Intent Succeeded"
Action: Rynko "Generate PDF"
Select invoice template
Map payment data:
- {{invoiceNumber}} → Stripe payment ID
- {{amount}} → Payment amount
- {{customerName}} → Customer name

Form Submission → Certificate PDF

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

Form submitted → Generate certificate PDF → Email to recipient

Weekly Schedule → Report Excel

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

Every Monday 9 AM → Generate report → Send to stakeholders

New Customer → Welcome Document

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

New customer created → Generate welcome packet PDF

Trigger Data Fields

When Rynko 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.rynko.dev/..."
  }
}

Make.com Integration

tip

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

Getting Started with Make.com

Step 1: Add Rynko to Your Scenario

Create a new scenario in Make.com
Click the + button to add a module
Search for Rynko
Select a trigger or action module

Step 2: Connect Your Account

Click Create a connection
Authorize via OAuth 2.0
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:

Get Records (from database/sheet)
Array Aggregator
Iterator
Rynko - Generate PDF
Sleep (rate limit buffer)

n8n Integration

tip

Community Node Available - Install n8n-nodes-rynko for full Rynko integration.

Installation

Via n8n UI:

Go to Settings → Community Nodes
Click Install a community node
Enter: n8n-nodes-rynko
Click Install

Via npm:

npm install n8n-nodes-rynko

Then restart your n8n instance.

Setting Up Credentials

Step 1: Generate API Key in Rynko

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

Step 2: Add Credentials in n8n

Go to Credentials → New
Search for "Rynko API"
Enter your API Key
Optionally update the API Base URL if self-hosted
Click Save

Available Nodes

Rynko Trigger Node

Starts workflows on document events:

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

Rynko 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 Rynko 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.

Rynko provides official SDKs for popular programming languages:

SDK	Package	Requirements
Node.js	`@rynko/sdk`	Node.js 18+
Python	`rynko`	Python 3.8+
Java	`dev.rynko:sdk`	Java 8+

Node.js SDK

Package: @rynko/sdk

npm install @rynko/sdk

import { Rynko } from '@rynko/sdk';

const client = new Rynko({
  apiKey: process.env.RYNKO_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: rynko

pip install rynko

from rynko import Rynko

client = Rynko(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 rynko import AsyncRynko
import asyncio

async def main():
    async with AsyncRynko(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: dev.rynko:sdk (Java 8+)

Maven

<dependency>
    <groupId>dev.rynko</groupId>
    <artifactId>sdk</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle

implementation 'dev.rynko:sdk:1.0.0'

Basic Usage

import dev.rynko.Rynko;
import dev.rynko.models.GenerateRequest;
import dev.rynko.models.GenerateResult;

// Initialize client
Rynko client = new Rynko(System.getenv("RYNKO_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("Job ID: " + result.getJobId());

// Wait for completion
GenerateResult completed = client.documents().waitForCompletion(
    result.getJobId(), 1000, 60000
);
System.out.println("Download URL: " + completed.getDownloadUrl());

Spring Boot Integration

import dev.rynko.Rynko;
import dev.rynko.models.GenerateRequest;
import dev.rynko.models.GenerateResult;

@Configuration
public class RynkoConfiguration {

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

    @Bean
    public Rynko rynko() {
        return new Rynko(apiKey);
    }
}

@Service
public class DocumentService {

    private final Rynko client;

    public DocumentService(Rynko rynko) {
        this.client = rynko;
    }

    public String generateInvoice(Invoice invoice) {
        GenerateResult result = client.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.getJobId();
    }
}

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, errorMessage, 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.rynko.dev/...",
    "expiresAt": "2025-12-05T10:30:00.000Z"
  }
}

Webhook Security

All webhooks include security headers for signature verification:

Header	Description
`X-Rynko-Signature`	HMAC-SHA256 signature (`v1=<hex>`)
`X-Rynko-Timestamp`	Unix timestamp of request
`X-Rynko-Event-Id`	Unique event identifier
`X-Rynko-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 Rynko dashboard.

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

# .env
RYNKO_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.rynko.dev
API Reference: https://docs.rynko.dev/api-reference
Support Email: support@rynko.dev
Status Page: status.rynko.dev

Overview​

Zapier Integration​

Getting Started with Zapier​

Step 1: Connect Your Account​

Step 2: Choose a Trigger or Action​

Step 3: Configure and Test​

Available Triggers​

Available Actions​

Available Searches​

Common Zapier Workflows​

Payment Received → Generate Invoice PDF​

Form Submission → Certificate PDF​

Weekly Schedule → Report Excel​

New Customer → Welcome Document​

Trigger Data Fields​

Make.com Integration​

Getting Started with Make.com​

Step 1: Add Rynko to Your Scenario​

Step 2: Connect Your Account​

Step 3: Configure the Module​

Available Modules​

Triggers (Watch Events)​

Actions​

Searches​

Make.com Scenario Examples​

Multi-Condition Document Router​

Batch Processing with Iterator​

n8n Integration​

Installation​

Setting Up Credentials​

Step 1: Generate API Key in Rynko​

Step 2: Add Credentials in n8n​

Available Nodes​

Rynko Trigger Node​

Rynko Action Node​

n8n Workflow Examples​

Scheduled Report Generation​

Conditional Logic with Switch Node​

Self-Hosted Benefits​

Native SDKs​

Node.js SDK​

Python SDK​

Java SDK​

Maven​

Gradle​

Basic Usage​

Spring Boot Integration​

Webhook Events​

Webhook Payload Format​

Webhook Security​

Authentication​

OAuth 2.0 (Zapier & Make.com)​

API Keys (n8n & SDKs)​

Rate Limits​

Best Practices​

1. API Key Security​

2. Error Handling​

3. Webhook Verification​

4. Use Batch Endpoints​

Troubleshooting​

Common Issues​

Getting Help​

Next Steps​