Best n8n Alternatives for API-First Developers 2026

import { 
  proxyActivities, 
  retry, 
  ActivityFailureError,
  ApplicationFailure
} from '@temporalio/workflow';
import * as wf from '@temporalio/workflow';

interface PaymentRequest {
  userId: string;
  amount: number;
  currency: string;
  idempotencyKey: string;
}

interface PaymentResult {
  transactionId: string;
  status: 'completed' | 'failed' | 'pending';
  timestamp: string;
}

const activities = proxyActivities<typeof import('./activities')>({
  startToCloseTimeout: '1 minute',
  retry: {
    initialInterval: '1 second',
    maximumInterval: '1 minute',
    maximumAttempts: 5,
    backoffCoefficient: 2.0,
    nonRetryableErrorTypes: ['InvalidPaymentError', 'FraudDetected']
  }
});

export async function paymentWorkflow(
  request: PaymentRequest
): Promise<PaymentResult> {
  let result: PaymentResult;

  try {
    result = await activities.processPaymentWithStripe(request);
  } catch (err) {
    if (err instanceof ApplicationFailure) {
      if (err.type === 'FraudDetected') {
        result = {
          transactionId: '',
          status: 'failed',
          timestamp: new Date().toISOString()
        };
      } else {
        throw err;
      }
    } else {
      throw err;
    }
  }

  if (result.status === 'completed') {
    await activities.sendConfirmationEmail(request.userId, result);
  }

  return result;
}

import axios from 'axios';
import nodemailer from 'nodemailer';

interface PaymentRequest {
  userId: string;
  amount: number;
  currency: string;
  idempotencyKey: string;
}

interface PaymentResult {
  transactionId: string;
  status: 'completed' | 'failed' | 'pending';
  timestamp: string;
}

const stripeApiKey = process.env.STRIPE_API_KEY!;
const emailTransporter = nodemailer.createTransport({
  host: process.env.SMTP_HOST,
  port: parseInt(process.env.SMTP_PORT || '587'),
  auth: {
    user: process.env.SMTP_USER,
    pass: process.env.SMTP_PASS
  }
});

export async function processPaymentWithStripe(
  request: PaymentRequest
): Promise<PaymentResult> {
  const stripeUrl = 'https://api.stripe.com/v1/payment_intents';

  const formData = new URLSearchParams();
  formData.append('amount', String(Math.round(request.amount * 100)));
  formData.append('currency', request.currency.toLowerCase());
  formData.append('idempotency_key', request.idempotencyKey);
  formData.append('description', `Payment for user ${request.userId}`);
  formData.append('automatic_payment_methods[enabled]', 'true');

  const response = await axios.post(stripeUrl, formData, {
    headers: {
      Authorization: `Bearer ${stripeApiKey}`,
      'Content-Type': 'application/x-www-form-urlencoded'
    }
  });

  const stripeStatus = response.data.status;
  let workflowStatus: 'completed' | 'failed' | 'pending' = 'pending';

  if (stripeStatus === 'succeeded') {
    workflowStatus = 'completed';
  } else if (stripeStatus === 'requires_action') {
    workflowStatus = 'pending';
  } else {
    workflowStatus = 'failed';
  }

  return {
    transactionId: response.data.id,
    status: workflowStatus,
    timestamp: new Date().toISOString()
  };
}

export async function sendConfirmationEmail(
  userId: string,
  result: PaymentResult
): Promise<void> {
  await emailTransporter.sendMail({
    from: 'payments@example.com',
    to: `user_${userId}@example.com`,
    subject: 'Payment Confirmation',
    html: `<p>Your payment ${result.transactionId} has been ${result.status}.</p>`
  });
}

const fetch = require('node-fetch');

async function processWebhookData(zapierData) {
  const stripeApiKey = process.env.stripe_api_key;

  const payload = {
    email: zapierData.email,
    first_name: zapierData.first_name,
    last_name: zapierData.last_name,
    metadata: {
      source: 'zapier_webhook',
      timestamp: new Date().toISOString()
    }
  };

  const response = await fetch('https://api.stripe.com/v1/customers', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${stripeApiKey}`,
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: new URLSearchParams(payload).toString()
  });

  const result = await response.json();

  if (!response.ok) {
    throw new Error(`Stripe API error: ${result.error.message}`);
  }

  return {
    customer_id: result.id,
    created: result.created,
    success: true
  };
}

return processWebhookData(inputData);

import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

interface WebhookPayload {
  event: string;
  data: {
    customer_id: string;
    amount: number;
    currency: string;
  };
  timestamp: string;
}

interface WorkflowState {
  stripeChargeId: string;
  emailSent: boolean;
  slackNotified: boolean;
}

async function chargeCustomer(customerId: string, amount: number, currency: string): Promise<string> {
  const stripeApiKey = Deno.env.get('STRIPE_SECRET_KEY')!;

  const chargeParams = new URLSearchParams({