Integrations

Connect Rynko to your applications, workflows, and automation platforms with our native integrations and official SDKs.

Integration Options

MCP Integration

AI-Native

Connect Claude Desktop, Cursor, Windsurf, VS Code, and Zed. Generate documents through natural conversation.

No-Code & SDKs

Native integrations for Zapier, Make.com, n8n plus official Node.js, Python, and Java SDKs.

Webhook Subscriptions

Receive real-time notifications when documents are generated or batch processing completes.

Google Sheets Add-on

Generate documents directly from your Google Sheets data with our native add-on.

Native Integrations

Rynko provides official integrations for popular platforms:

Platform	Type	Authentication	Status
MCP (AI Agents)	Claude, Cursor, Windsurf, VS Code, Zed	PAT Token	Available
Google Sheets	Native Add-on	OAuth 2.0	Available
Zapier	Native Integration	OAuth 2.0	Available
Make.com	Native Integration	OAuth 2.0	Available
n8n	Community Node	API Key	Available
Node.js SDK	@rynko/sdk	API Key	Available
Python SDK	rynko	API Key	Available
Java SDK	com.rynko:sdk	API Key	Available

Official SDKs

Install our official SDKs for the best developer experience:

info

SDKs include full TypeScript/Python type definitions (and Javadoc for Java), webhook signature verification, and comprehensive error handling.

Node.js

npm install @rynko/sdk

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

const client = new Rynko({ apiKey: process.env.RYNKO_API_KEY });

// Queue document generation (async operation)
const job = await client.documents.generate({
  templateId: 'invoice-template',
  format: 'pdf',
  variables: {
    invoiceNumber: 'INV-001',
    customerName: 'Acme Corp',
    total: 1500.00
  }
});

// Wait for completion to get download URL
const completed = await client.documents.waitForCompletion(job.jobId);
console.log('Download URL:', completed.downloadUrl);

Python

pip install rynko

from rynko import Rynko

client = Rynko(api_key=os.environ["RYNKO_API_KEY"])

# Queue document generation (async operation)
job = client.documents.generate(
    template_id="invoice-template",
    format="pdf",
    variables={
        "invoiceNumber": "INV-001",
        "customerName": "Acme Corp",
        "total": 1500.00
    }
)

# Wait for completion to get download URL
completed = client.documents.wait_for_completion(job["jobId"])
print("Download URL:", completed["downloadUrl"])

Java

<dependency>
    <groupId>com.rynko</groupId>
    <artifactId>sdk</artifactId>
    <version>1.3.5</version>
</dependency>

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

Rynko client = new Rynko(System.getenv("RYNKO_API_KEY"));

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()
);

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

Full SDK Documentation →

Flow (AI Validation Gateway)

Use the same SDKs to submit runs to Flow gates, poll for results, and manage approvals programmatically:

Node.js

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

const client = new Rynko({ apiKey: process.env.RYNKO_API_KEY });

// Submit a run to a gate
const run = await client.flow.submitRun('gate_abc123', {
  input: {
    ticketId: 'TICK-001',
    priority: 'critical',
    summary: 'Payment processing is down for all users',
    estimatedHours: 8,
  },
});

// Wait for the run to reach a terminal state
const result = await client.flow.waitForRun(run.id, {
  pollInterval: 1000,
  timeout: 60000,
});

if (result.status === 'validated' || result.status === 'approved') {
  console.log('Validated!', result.output);
} else if (result.status === 'validation_failed') {
  console.log('Validation errors:', result.errors);
} else if (result.status === 'pending_approval') {
  console.log('Sent to human reviewers for approval');
}

Python

from rynko import Rynko

client = Rynko(api_key=os.environ["RYNKO_API_KEY"])

# Submit a run to a gate
run = client.flow.submit_run(
    "gate_abc123",
    input={
        "ticketId": "TICK-001",
        "priority": "critical",
        "summary": "Payment processing is down for all users",
        "estimatedHours": 8,
    },
)

# Wait for the run to reach a terminal state
result = client.flow.wait_for_run(run["id"], timeout=60.0)

if result["status"] in ("validated", "approved"):
    print("Validated!", result.get("output"))
elif result["status"] == "validation_failed":
    print("Validation errors:", result.get("errors"))
elif result["status"] == "pending_approval":
    print("Sent to human reviewers for approval")

Java

import dev.rynko.Rynko;
import dev.rynko.models.FlowRun;
import dev.rynko.models.SubmitRunRequest;

Rynko client = new Rynko(System.getenv("RYNKO_API_KEY"));

// Submit a run to a gate
FlowRun run = client.flow().submitRun("gate_abc123",
    SubmitRunRequest.builder()
        .inputField("ticketId", "TICK-001")
        .inputField("priority", "critical")
        .inputField("summary", "Payment processing is down for all users")
        .inputField("estimatedHours", 8)
        .build()
);

// Wait for the run to reach a terminal state
FlowRun result = client.flow().waitForRun(run.getId());

System.out.println("Status: " + result.getStatus());

tip

Flow gates are created and configured in the Flow dashboard or via the REST API. SDKs provide read-only gate access plus full run, approval, and delivery management.

No-Code Platforms

Google Sheets Add-on

tip

Native Add-on - Install directly from the Google Workspace Marketplace.

Generate documents directly from spreadsheet data:

• Select rows to generate documents
• Map columns to template variables
• Batch generate multiple documents
• Automatic variable detection

Google Sheets Add-on Guide →

Zapier

tip

Native Integration - Find Rynko in the Zapier app directory.

• 2 Triggers: Document Generated, Batch Completed
• 3 Actions: Generate PDF, Generate Excel, Generate Batch
• 1 Search: Find Document by Job ID

Make.com (Integromat)

tip

Native Integration - Available in the Make.com marketplace.

• 2 Watch Modules for document events
• 3 Action Modules for generating documents
• Visual workflow builder integration

n8n

tip

Community Node - Install n8n-nodes-rynko

• Rynko Trigger node for document events
• Rynko Action node for generation operations
• Simple API Key authentication

Full Integration Documentation →

Webhook Subscriptions

Subscribe to real-time document generation events for custom integrations:

Event	Description
document.generated	Document successfully generated
document.failed	Document generation failed
batch.completed	Batch processing completed
batch.failed	Batch processing failed
flow.run.completed	Flow run completed successfully
flow.run.approved	Flow run approved by reviewer
flow.run.rejected	Flow run rejected by reviewer
flow.run.review_required	Flow run requires human review
flow.delivery.failed	Flow delivery failed

Webhook Security

All webhooks are signed with HMAC-SHA256 for verification:

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

const event = verifyWebhookSignature({
  payload: requestBody,
  signature: headers['x-rynko-signature'],
  secret: process.env.WEBHOOK_SECRET
});

Full Webhook Documentation →

Common Integration Patterns

Form Submission → Generate Certificate

When someone completes a course or event, automatically generate a certificate PDF.

Zapier: Form Submitted (Trigger) → Rynko Generate PDF (Action)

Payment → Invoice PDF

When a payment succeeds (Stripe, PayPal), generate an invoice PDF.

Zapier: Payment Succeeded (Trigger) → Rynko Generate PDF (Action)

Spreadsheet → Batch Documents

Generate documents for each row in a spreadsheet.

Google Sheets Add-on: Select rows → Generate Documents

Schedule → Weekly Report

Generate weekly/monthly reports on a schedule.

Zapier: Schedule Weekly (Trigger) → Rynko Generate Excel (Action)

Quick Start

1. Choose your integration method:

   • SDK for programmatic access
   • Google Sheets Add-on for spreadsheet workflows
   • Zapier/Make/n8n for no-code automation
   • Direct API for custom implementations

2. Authenticate:

   • SDKs & n8n: Create an API key in your dashboard
   • Google Sheets & Zapier & Make.com: Connect via OAuth 2.0

3. Start building:

   • Generate PDF and Excel documents
   • Use batch generation for multiple documents
   • Subscribe to webhook events

Getting Started → API Reference →