N8n Hebrew Workflows

n8n Hebrew Workflows

Instructions

Step 1: Identify the Automation Pattern

Map the user's Israeli business need to an n8n workflow pattern:

Scheduled flows start with a Schedule Trigger and should add Shabbat/holiday pausing (Step 4). Event-driven flows (payment confirmations, form submissions) start with a Webhook trigger. Add a Code node early when Hebrew text needs encoding/RTL handling (Step 3), and an AI Agent node when categorization or summarization is involved (Step 7).

Step 2: Connect Israeli APIs in n8n

Morning (formerly Green Invoice) API

Morning ("hashbonit yeruka" / חשבונית ירוקה) uses API key + secret to obtain a JWT token (NOT OAuth2). Configure HTTP Request:

POST https://api.greeninvoice.co.il/api/v1/account/token
Body: { "id": "{{$env.GREEN_INVOICE_API_KEY}}", "secret": "{{$env.GREEN_INVOICE_API_SECRET}}" }

The response contains a JWT token valid for 60 minutes. Pass it to subsequent requests as Authorization: Bearer {{$json.token}}.

Israel Invoice Reform 2026 (threshold step-down): Tax invoices over the threshold require an allocation number (mispar haktza'a) from the Tax Authority. The threshold drops mid-year:

Build the threshold as a configurable variable, not a hardcoded number. Check Morning's API docs for the latest allocation workflow.

Amounts are in decimal shekels (NOT agorot). price: 50 means 50 NIS, not 50 agorot.

Common Morning endpoints:

Document type codes: 10 (Price Quote / hatzaat mechir), 305 (Tax Invoice / hashbonit mas), 320 (Tax Invoice + Receipt / hashbonit mas + kabala), 330 (Credit Note / hashbonit zikui), 400 (Receipt / kabala).

Consult references/israeli-api-endpoints.md for full endpoint details and response schemas.

EZCount (EasyCount) API

EZCount is a popular Morning alternative for SMB invoicing. REST + JSON, authenticated via api_key + api_email in the request body (not Bearer, not OAuth).

POST https://api.ezcount.co.il/api/createDoc
Body: { "api_key": "...", "api_email": "...", "developer_email": "you@example.com",
        "type": 320, "customer_name": "שם הלקוח", "customer_email": "client@example.com",
        "item": [{ "details": "שירותי ייעוץ", "amount": 1, "price": 500, "vat_type": "INC" }] }

Document type codes match the Tax Authority numbering used by Morning (305/320/330/400). Amounts are decimal shekels. The same Invoice Reform 2026 allocation flow applies; if the API returns allocation_status: 'pending', retry after 30s. EZCount and Morning produce the same legal output, so pick by which accounting suite the user already uses.

israeli-bank-scrapers via Code Node

n8n has no native Israeli bank node. Use a Code node to run israeli-bank-scrapers programmatically (it is a Node.js library, NOT a CLI). Requires Node.js >= 22.12.0.

const { createScraper, CompanyTypes } = require('israeli-bank-scrapers');
const scraper = createScraper({
  companyId: CompanyTypes.hapoalim,
  startDate: new Date('2026-01-01'),
  combineInstallments: false,
  showBrowser: false
});
const result = await scraper.scrape({ username: $env.BANK_USER, userPassword: $env.BANK_PASS });
if (!result.success) throw new Error(`${result.errorType}: ${result.errorMessage}`);
return result.accounts.flatMap(a => a.txns.map(txn => ({ json: txn })));

Supported scrapers: hapoalim, leumi, discount, mizrahi, otsarHahayal, beinleumi, massad, yahav, beyahadMishkantaot, oneZero, behatsdaa, visaCal, max (formerly Leumi Card), isracard, amex, mercantile.

Cloudflare blocking (2026): Cloudflare's bot detection blocks headless browsers on Amex and Isracard. The maintained fork @sergienko4/israeli-bank-scrapers uses Camoufox as a workaround: npm install @sergienko4/israeli-bank-scrapers.

Store credentials in n8n's credential store, never in workflow JSON.

data.gov.il CKAN API

GET https://data.gov.il/api/3/action/datastore_search?resource_id=<guid>&q=<term>&limit=100

Useful resource IDs: Non-Profit Registry (be5b7935-3922-45d4-9638-08871b17ec95) for registered amutot; trade statistics by HS code (various IDs). The API returns Hebrew field names; use a Code node to normalize keys to English before downstream processing.

Israeli SMS Gateways

019 Telzar example:

POST https://019sms.co.il/api
Headers: Authorization: Bearer {{$env.SMS_019_TOKEN}}
Body: { "from": "MyBusiness", "to": "{{$json.phone}}", "message": "{{$json.text}}" }

Phone numbers must be international format 972XXXXXXXXX (drop leading 0). Normalize in a Code node:

const phone = $input.first().json.phone.replace(/[-\s]/g, '');
const formatted = phone.startsWith('0') ? '972' + phone.slice(1)
                : phone.startsWith('+972') ? phone.slice(1) : phone;
return [{ json: { ...$input.first().json, phone: formatted } }];

Step 3: Handle Hebrew Data in n8n Nodes

n8n Code nodes process strings as UTF-8, so Hebrew works natively. Problems arise at boundaries (API responses, CSV exports, email templates):

NIS currency formatting:

new Intl.NumberFormat('he-IL', { style: 'currency', currency: 'ILS', minimumFractionDigits: 2 }).format(amount);
// 12345.60  ->  12,345.60 ₪

Date parsing: Israeli docs use DD/MM/YYYY. Morning API returns ISO 8601, but government datasets often return DD/MM/YYYY:

function parseIsraeliDate(s) { const [d, m, y] = s.split('/').map(Number); return new Date(y, m - 1, d); }
const hebrewMonths = { 'ינואר': 0, 'פברואר': 1, 'מרץ': 2, 'אפריל': 3, 'מאי': 4, 'יוני': 5,
                        'יולי': 6, 'אוגוסט': 7, 'ספטמבר': 8, 'אוקטובר': 9, 'נובמבר': 10, 'דצמבר': 11 };

Step 4: Shabbat-Aware Scheduling

Business workflows in Israel must not run during Shabbat (Friday sundown to Saturday sundown) and Jewish holidays. n8n's Schedule Trigger has no native support, so add a check node at the start of every scheduled workflow.

Architecture: Schedule Trigger -> HTTP Request (Hebcal) -> IF (is Shabbat?) -> Continue or Stop

GET https://www.hebcal.com/shabbat?cfg=json&geonameid=293397&M=on

geonameid=293397 is Tel Aviv. Other common cities:

Code node to gate the workflow on candle lighting / havdalah:

const now = new Date();
const data = $input.first().json;
const candles = data.items.find(i => i.category === 'candles');
const havdalah = data.items.find(i => i.category === 'havdalah');
if (candles && havdalah) {
  const start = new Date(candles.date), end = new Date(havdalah.date);
  if (now >= start && now <= end) return []; // empty output stops workflow
}
return $input.all();

For Jewish holidays, query https://www.hebcal.com/hebcal?v=1&cfg=json&year=now&month=now&maj=on&mod=on and filter for yomtov: true. Consult references/shabbat-cron-patterns.md for pre-built patterns.

Step 5: Israeli Payment Gateway Webhooks

Cardcom

Cardcom sends POST with form-encoded data:

For modern integrations, use the Cardcom API v11 endpoint (https://secure.cardcom.solutions/api/v11); it also lets you register webhooks for document-creation events. URLs must be HTTPS and publicly routable (no localhost; use ngrok or Cloudflare Tunnel in dev). Full docs: https://secure.cardcom.solutions/api/v11/DOCS.

Tranzila

Tranzila callbacks deliver GET parameters:

https://your-n8n.example.com/webhook/tranzila-callback?Response=000&index=12345&sum=100.00&currency=1

Response=000 is approved. Currency: 1 = ILS, 2 = USD, 3 = GBP, 7 = EUR. Rone = installments.

Tranzila API v2 offers modern server-to-server (SAQ-D) plus iframe / hosted fields. Authentication uses an X-tranzila-api-app-key header (header confirmed via Stoplight API explorer at docs.tranzila.com). v2 supports Bit, tokenization, recurring billing, refunds, and 3D Secure (mandatory under SHVA rules). Prefer v2 over the legacy tranzila71dl.cgi CGI pattern. Bit flow: server calls Tranzila v2, response includes a URL to embed in an iframe (QR code + phone push). See https://docs.tranzila.com/ for the v2 documentation.

Grow by Meshulam

Grow sends webhooks as POST. Important: the Grow API uses multipart/form-data (not JSON). After receiving a webhook, call approveTransaction to finalize the payment.

Webhook payload includes: webhookKey, transactionCode, transactionType, asmachta (transaction reference), paymentSum, paymentDate, fullName, payerPhone, payerEmail, cardSuffix, cardBrand, paymentsNum.

Bit Payments

Bit is Israel's most popular mobile payment method, available through Tranzila (API v2) and Grow by Meshulam, not as a standalone API. Via Tranzila v2: create a payment page with bit: true; the customer scans a QR code or is redirected to Bit. Via Grow: enable Bit in the merchant dashboard; Bit transactions appear in the same webhook flow with a different transactionType.

Webhook Authentication

n8n's Webhook node supports four auth modes: None, Basic Auth, Header Auth, JWT Auth. After CVE-2026-21858 (Ni8mare), the "None" mode on a publicly-routable webhook is effectively a vulnerability; use Header Auth (default for Israeli SMS callbacks), Basic Auth (private/VPN), or JWT Auth (cross-org).

n8n has no built-in HMAC verifier and no automatic exp/iss/aud claim validation on JWTs. See references/webhook-auth-patterns.md for HMAC verification and JWT claim-validation Code-node snippets.

IP whitelisting: Cardcom and Tranzila require your webhook server's IP to be whitelisted. If self-hosting, use a static IP or a reverse proxy with a fixed egress IP.

Step 6: Self-Hosting Considerations

n8n 2.x Security Patches and Breaking Changes

n8n 2.0 shipped in December 2025; the stable line is 2.21.x as of May 2026 (beta on 2.22.0, new minor most weeks). Pin a specific tag in production, never n8nio/n8n:latest.

CRITICAL security patch (pin >= 2.10.1): CVE-2026-21858 ("Ni8mare", CVSS 10.0) is an unauthenticated RCE via webhook/form requests, disclosed January 2026 and patched in 1.121.0 and 2.10.1. A chained pair (CVE-2026-27493 + CVE-2026-27577, March 2026) escalates to host RCE on versions <2.10.1, <2.9.3, <1.123.22. Any public Webhook node (every payment-gateway workflow in this skill) makes the host exploitable. Pin >= 2.10.1, ideally current 2.21.x.

Key n8n 2.0 changes affecting Israeli workflows:

To re-enable Execute Command, override NODES_EXCLUDE so it no longer contains n8n-nodes-base.executeCommand (empty list works), then restart n8n:

NODES_EXCLUDE=[]

There is no N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE variable (a common hallucination). Enabling Execute Command lets anyone with workflow edit access run arbitrary shell, so use only in trusted single-user deployments. Code nodes remain the recommended path.

Israeli Cloud Options

Israel's Privacy Protection Authority (PPA) does not mandate that all data stay in Israel, but restricts transfers to countries without adequate data protection. For workflows processing PII (teudat zehut, bank, medical), choose an Israeli DC or verify destination adequacy on the PPA's approved list.

Docker Compose for Self-Hosted n8n

services:
  n8n:
    # Must be >= 2.10.1 to be patched for CVE-2026-21858 (Ni8mare).
    image: n8nio/n8n:2.21.4
    restart: unless-stopped
    ports: ["5678:5678"]
    environment:
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://${N8N_HOST}/
      - GENERIC_TIMEZONE=Asia/Jerusalem
      - TZ=Asia/Jerusalem
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
    volumes:
      - n8n_data:/home/node/.n8n
volumes:
  n8n_data:

Notes:

• n8n 1.0+ uses built-in user management; old N8N_BASIC_AUTH_* vars are removed. n8n prompts for an owner account on first launch.
• Set both GENERIC_TIMEZONE=Asia/Jerusalem AND TZ=Asia/Jerusalem. Without these, Schedule Trigger nodes default to UTC and Shabbat calculations drift 2-3 hours. Israeli DST runs Friday-before-last-Sunday-of-March through last Sunday of October.
• Never run :latest in production after the 2026 CVE chain. Pin the tag and update via controlled redeploy.

Step 7: n8n AI Agent Nodes for Israeli Workflows

n8n 2.x ships native LangChain integration (the "Advanced AI" node group): 70+ AI nodes including Tools Agent, Conversational Agent, Memory (Window/Summary Buffer), Vector Store nodes (Pinecone, Qdrant, Supabase pgvector for RAG), and Model nodes for OpenAI (GPT-4o), Anthropic (Claude 3.5 Sonnet, Claude Opus 4.7 with adaptive thinking), and local models via Ollama.

RAG with Israeli content: Connect a Vector Store node (Pinecone, Qdrant, Supabase pgvector) to an AI Agent for retrieval over Israeli corpora. Use a multilingual embedding model that handles Hebrew (Cohere embed-multilingual-v3.0 or OpenAI text-embedding-3-large); the default text-embedding-ada-002 is weak on Hebrew.

Example: AI bank transaction categorizer. Schedule -> Code (bank scraper) -> AI Agent (categorize) -> Google Sheets:

return $input.all().map(item => ({ json: {
  date: item.json.date, description: item.json.description, amount: item.json.chargedAmount,
  prompt: `Categorize this Israeli bank transaction. Transaction: "${item.json.description}" for ${item.json.chargedAmount} NIS on ${item.json.date}.
Categories: הכנסות, שכר, ספקים, מע"מ, ביטוח לאומי, שכירות, הוצאות משרד, אחר.
Respond with ONLY the Hebrew category name.`
}}));

n8n MCP nodes:

• MCP Client Tool (@n8n/n8n-nodes-langchain.toolMcp): attach as a sub-node so an AI Agent can call tools on an external MCP server (e.g. agentskills.co.il's hebcal, israeli-bank, data-gov-il servers).
• MCP Server Trigger: exposes an n8n workflow itself as an MCP tool, so external clients (Claude Desktop, Cursor, Windsurf, custom GPTs) can discover and invoke your Morning-invoice-lookup or bank-scraper workflow.

Step 8: When to Use n8n vs Alternatives

Choose n8n when you need self-hosting for Israeli data residency, unlimited automations, or full code access for Israeli API quirks (Hebrew encoding, phone formatting, VAT, allocation numbers).

Step 9: Workflow JSON Import/Export

n8n workflows are JSON documents. Agents building workflows programmatically must understand the shape:

{
  "name": "Morning daily reconciliation",
  "nodes": [{
    "parameters": { "rule": { "interval": [{ "field": "cronExpression", "expression": "0 6 * * 0-4" }] } },
    "name": "Schedule Trigger", "type": "n8n-nodes-base.scheduleTrigger",
    "typeVersion": 1.2, "position": [240, 300]
  }],
  "connections": {
    "Schedule Trigger": { "main": [[{ "node": "Get Token", "type": "main", "index": 0 }]] }
  }
}

• `nodes`: each has unique name (used as connection key), type (e.g. n8n-nodes-base.httpRequest), typeVersion (must match a version n8n supports), parameters, and position.
• `connections`: keyed by source node name, mapping main output to an array of arrays of { node, type, index } targets (double array allows multiple outputs, e.g. IF branches).
• Export via UI Download or GET /api/v1/workflows/{id}; import via "Import from File" or POST /api/v1/workflows. After importing into n8n 2.0 you must publish before it runs. typeVersion changes between releases.

Step 10: Credentials Setup for Israeli APIs

n8n stores secrets in its encrypted credential store, never inline in workflow JSON:

• Morning (Green Invoice) JWT: no native credential. Chain HTTP Request nodes; the first calls /account/token, later nodes send Authorization: Bearer {{token}} via Header Auth or an expression. Token expires after 60 minutes, so refresh per execution.
• Israeli SMS gateways (019, InforUMobile): Header Auth credential, name Authorization, value Bearer <token>.
• Payment gateways (Cardcom, Tranzila, Grow): store merchant IDs / API keys as Generic Credential, referenced via {{$credentials.fieldName}}. Grow's multipart/form-data requests still pull secrets from the credential.
• For self-hosted n8n, set a stable N8N_ENCRYPTION_KEY so the credential store survives restarts.

Examples

Example 1: Connect Morning to n8n for daily invoice reconciliation

User: "Every morning, pull yesterday's Morning invoices and flag any still unpaid."

1. Schedule Trigger (scheduleTrigger): cron 0 6 * * 0-4 (09:00 Israel winter, Sun-Thu). 2. HTTP Request, "Get Token": POST /api/v1/account/token with { id, secret }. Output: JWT. 3. HTTP Request, "Search Documents": POST /api/v1/documents/search with Authorization: Bearer {{$json.token}}, body filtering fromDate/toDate to yesterday and type to 305/320. 4. IF node: branch on status (open vs closed). 5. HTTP Request (SMS) or Send Email: notify bookkeeper, Hebrew body wrapped in <div dir="rtl">.

Wrap the whole flow with the Shabbat check from Step 4 if it must never run on a holiday weekday.

Example 2: Bank transactions to a Google Sheet, holiday-aware

User: "Scrape my business account nightly and append new transactions to a sheet, but skip Shabbat and holidays."

1. Schedule Trigger: cron for a weeknight time. 2. HTTP Request (Hebcal) + Code (Shabbat check) from Step 4. 3. Code node: run israeli-bank-scrapers via createScraper() (Step 2), one item per transaction. 4. Code node: normalize Hebrew descriptions, format amounts with Intl.NumberFormat('he-IL', ...), parse DD/MM/YYYY dates. 5. Google Sheets (Append): write rows. 6. Separate Error Trigger workflow catches failed runs (see Gotchas).

Recommended MCP Servers

• hebcal: Hebrew/Jewish calendar and Shabbat times, alternative to calling Hebcal HTTP in every workflow.
• israeli-bank: Israeli bank account data; lets an agent pull transactions without running israeli-bank-scrapers in a Code node.
• data-gov-il: Israeli government open data (CKAN), query registries without hand-building HTTP Request nodes.

Reference Links

Gotchas

• Agents pin `:latest` or an old 1.x tag. Versions before 2.10.1 / 1.121.0 are vulnerable to Ni8mare (CVE-2026-21858, CVSS 10.0) plus the March 2026 chain (CVE-2026-27493 + CVE-2026-27577). Any public Webhook node makes the host exploitable. Pin >= 2.10.1 (current stable 2.21.x).
• Agents default to UTC for schedule triggers. Israel uses Asia/Jerusalem (UTC+2/+3); DST runs Friday-before-last-Sunday-of-March through last Sunday of October. Always set GENERIC_TIMEZONE and verify timing after every DST change.
• Agents format dates as MM/DD/YYYY. Israeli docs use DD/MM/YYYY. Morning returns ISO 8601, but government datasets often return DD/MM/YYYY as strings.
• Agents send Israeli phone numbers with leading zero. SMS gateways require 972XXXXXXXXX. 050-1234567 becomes 972501234567.
• Agents assume VAT is included. Israeli invoices often show amounts before VAT (lifnei maam). Morning returns both amount (before VAT) and totalAmount (with VAT). Current VAT is 18% (2026).
• Agents miss that Shabbat times vary by city. Candle lighting: Jerusalem 40 min before sunset, Haifa/Zikhron Ya'akov 30 min, Tel Aviv and all other cities 18 min. A single hardcoded time will cause runs during Shabbat in some cities.
• Execute Command node is disabled by default in n8n 2.0. If your workflow used it for bank scraping it silently fails after upgrade. Migrate to Code nodes or re-enable via NODES_EXCLUDE (there is NO N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE variable, that is a hallucination).
• Morning amounts are shekels, not agorot. price: 50 = 50 NIS. Different from some Israeli payment gateways that use agorot.
• Invoice Reform 2026 threshold drops June 1, 2026. Invoices over the threshold (10K NIS through May 31, 5K NIS from June 1) created via API require allocation numbers from the Tax Authority. Make the threshold a workflow variable, not a hardcoded literal.
• n8n editor keyboard shortcuts break under Hebrew layout. Canvas reads e.key instead of e.code, so Ctrl+C produces e.key = 'ב' and shortcuts fail. Switch input to English while editing, or use menu actions. Tracked in n8n GitHub issue #12569.
• n8n's expression editor has no RTL support. Hebrew renders left-to-right. For long Hebrew literals, store them in env vars or static workflow data and reference by name.
• Unattended workflows fail silently without an Error Trigger. A scheduled scrape or sync that throws just stops. Create a separate workflow starting with an Error Trigger node that sends a Hebrew alert to Slack/SMS. For transient failures (Cloudflare, expired tokens, rate limits), enable per-node Retry On Fail with a sensible wait.

Bundled Resources

References

• references/israeli-api-endpoints.md -- Israeli API endpoint reference (Morning, data.gov.il, SMS gateways, payment gateways, Hebcal).
• references/shabbat-cron-patterns.md -- Pre-built Shabbat-aware scheduling patterns with Hebcal integration.
• references/webhook-auth-patterns.md -- HMAC signature verification + JWT claim validation Code-node snippets.

Troubleshooting

Morning (Green Invoice) API returns 401 Unauthorized

JWT expired (60 min TTL). Add a token refresh step at the start of every execution. Store the token in $getWorkflowStaticData('global') with a timestamp and refresh if older than 55 min.

Hebrew text appears garbled in CSV export

Missing UTF-8 BOM, so Excel reads it as ANSI. Prepend '' to CSV content, or set Spreadsheet File encoding to UTF-8-BOM.

Webhook not receiving Cardcom callbacks

Cardcom needs the callback URL publicly accessible with valid SSL. Use nginx/Caddy + Let's Encrypt. Ensure WEBHOOK_URL matches the public URL. Whitelist n8n's IP in the Cardcom dashboard.

Schedule Trigger runs during Shabbat despite Hebcal check

Server timezone is UTC, not Asia/Jerusalem. Verify GENERIC_TIMEZONE=Asia/Jerusalem, restart n8n, and log new Date().toString() in a Code node to confirm.

israeli-bank-scrapers fails in Code node

n8n 2.0 runs Code in an isolated task runner; the package and Puppeteer/Playwright may not be available. Install it in the runner env. Give the container >= 1GB memory for Chromium. Execute Command (legacy approach) is disabled by default in 2.0.

Cloudflare blocks bank scraper for Amex/Isracard

Switch to the maintained fork: npm install @sergienko4/israeli-bank-scrapers (uses Camoufox).

Israeli API Endpoints Reference for n8n

Quick reference for configuring HTTP Request nodes when connecting to Israeli services.

Morning (formerly Green Invoice) API

Base URL: https://api.greeninvoice.co.il/api/v1

Note: The company rebranded from "Green Invoice" to "Morning" (חשבונית ירוקה). The API domain remains api.greeninvoice.co.il.

Authentication

Authentication is API key + secret -> JWT. This is NOT OAuth2.

Token TTL: 60 minutes. Refresh proactively before expiry.

Document Endpoints

Document Types (type field)

Israel Invoice Reform 2026

Tax invoices (type 305, 320) over the threshold require an allocation number (mispar haktza'a) from the Israel Tax Authority via SHAAM clearance. Threshold schedule:

When creating documents via API, check Morning's documentation for the allocation workflow applicable to API-created documents. Build the threshold as a workflow variable rather than a hardcoded literal.

Client Endpoints

Payment Endpoints

Common Response Fields

Amounts are in decimal shekels. amount: 50 means 50.00 NIS. Do not multiply or divide by 100.

---

EZCount (EasyCount) API

Base URL: https://api.ezcount.co.il/api

EZCount is a Morning alternative for SMB invoicing in Israel.

Authentication

Authentication via api_key + api_email in the request body (not OAuth, not Bearer).

Document Endpoints

Document Type Codes

Same Tax Authority codes as Morning: 10 (price quote), 305 (tax invoice), 320 (tax invoice / receipt), 330 (credit note), 400 (receipt).

Israel Invoice Reform 2026

EZCount auto-clears qualifying tax invoices against SHAAM and returns the allocation number in the response. If allocation_status: 'pending', retry after 30 seconds before treating the invoice as final. SDK code samples in PHP, Java, .NET, ASP, Ruby, Node, and Python on the EZCount developer portal.

Common Response Fields

Amounts are in decimal shekels. Same convention as Morning.

---

data.gov.il CKAN API

Base URL: https://data.gov.il/api/3

Core Endpoints

Useful Resource IDs

Note: The Companies Registry resource ID may change. Verify the current resource ID via the data.gov.il portal before using.

Query Examples

Search non-profits by name:

GET https://data.gov.il/api/3/action/datastore_search?resource_id=be5b7935-3922-45d4-9638-08871b17ec95&q=עמותה

Response Format

{
  "success": true,
  "result": {
    "records": [...],
    "total": 12345,
    "fields": [
      { "id": "field_name", "type": "text" }
    ]
  }
}

Note: Field names are in Hebrew. Normalize to English keys in a Code node for downstream compatibility.

---

Israeli SMS Gateways

019 Telzar

Base URL: https://019sms.co.il/api

Send SMS request:

Headers:
  Content-Type: application/json
  Authorization: Bearer <token>
Body:
{
  "from": "MyBusiness",
  "to": "972501234567",
  "message": "הודעה בעברית"
}

InforUMobile

Base URL: https://api.inforu.co.il

InforUMobile has a legacy XML API and newer JSON API:

JSON API endpoint: https://api.inforu.co.il/api/v2/SMS/SendSms

Send SMS body (JSON API):

{
  "Message": "הודעה בעברית",
  "Recipients": [{ "Phone": "972501234567" }],
  "Settings": {
    "Sender": "MyBusiness",
    "MessageType": 1
  }
}

Phone Number Format Rules

Israeli mobile prefixes: 050, 051, 052, 053, 054, 055, 058

---

Israeli Payment Gateways

Cardcom

Documentation: https://www.cardcom.solutions/

Callback fields:

Tranzila

Documentation: https://docs.tranzila.com/

Tranzila API v2 authenticates via the X-tranzila-api-app-key HTTP header (not Basic Auth, not query parameters). v2 covers server-to-server (SAQ-D), iframe, hosted fields, Bit (init returns an iframe URL with QR + push), tokenization, recurring billing, refunds, and 3D Secure.

Callback query parameters:

Tranzila API v2 also supports Bit payments. For new integrations, prefer v2 over the legacy CGI pattern.

Grow by Meshulam

Documentation: https://grow-il.readme.io/

Important: Grow API requests use multipart/form-data, not JSON.

Webhook payload fields:

After receiving a webhook, you must call `approveTransaction` to finalize the payment.

Grow also supports Bit payments when enabled in the merchant dashboard.

---

Hebcal API

Base URL: https://www.hebcal.com

Shabbat Times

Holiday Calendar

Israeli City Geoname IDs

Shabbat Response Format

{
  "title": "Shabbat Times for Tel Aviv-Yafo",
  "date": "2026-01-16",
  "items": [
    {
      "title": "Candle lighting: 4:38pm",
      "date": "2026-01-16T16:38:00+02:00",
      "category": "candles",
      "memo": "Parashat Beshalach"
    },
    {
      "title": "Havdalah (50 min): 5:42pm",
      "date": "2026-01-17T17:42:00+02:00",
      "category": "havdalah"
    }
  ]
}

Holiday Response Fields

Shabbat-Aware Scheduling Patterns for n8n

Pre-built patterns for n8n workflows that need to respect Shabbat and Jewish holidays.

Core Concept

n8n's built-in Schedule Trigger node has no concept of Shabbat or Jewish holidays. The solution is a two-node pattern at the start of every scheduled workflow:

1. Schedule Trigger fires on schedule 2. Shabbat Gate (HTTP Request + Code) checks if it is currently Shabbat or a holiday, and stops the workflow if so

This pattern is appended to the beginning of every schedule-triggered workflow. It adds ~500ms latency per check (one API call to Hebcal).

Pattern 1: Weekly Business Workflow (Sunday-Thursday)

For workflows that should run during Israeli business days only.

Schedule Trigger cron expression: 0 9 * * 0-4 (9:00 AM, Sunday through Thursday)

This handles the simple case. Israeli business week is Sunday (0) through Thursday (4). Friday and Saturday are excluded by the cron itself, so no Shabbat check is needed for the standard work week.

When to add a Shabbat gate on top of this: When the workflow runs on Friday (before Shabbat) or needs to account for holidays that fall on weekdays.

Pattern 2: Daily Workflow with Shabbat Gate

For workflows that run every day but must pause during Shabbat.

Schedule Trigger cron expression: 0 */3 * * * (every 3 hours)

Shabbat Gate Code Node:

// Runs after HTTP Request to Hebcal shabbat endpoint
const now = new Date();
const data = $input.first().json;

const candles = data.items?.find(i => i.category === 'candles');
const havdalah = data.items?.find(i => i.category === 'havdalah');

if (!candles || !havdalah) {
  // No Shabbat data available (unlikely), proceed with caution
  return $input.all();
}

const shabbatStart = new Date(candles.date);
const shabbatEnd = new Date(havdalah.date);

if (now >= shabbatStart && now <= shabbatEnd) {
  // Currently Shabbat, stop workflow
  return [];
}

// Not Shabbat, continue
return $input.all();

Hebcal HTTP Request node configuration:

Method: GET
URL: https://www.hebcal.com/shabbat
Query Parameters:
  cfg: json
  geonameid: 293397  (Tel Aviv, change per your location)
  M: on

Pattern 3: Holiday-Aware Scheduling

For workflows that must also pause on Jewish holidays (Yom Tov).

Extended Code Node (replaces the basic Shabbat gate):

const now = new Date();
const shabbatData = $('Shabbat Check').first().json;
const holidayData = $('Holiday Check').first().json;

// Check Shabbat
const candles = shabbatData.items?.find(i => i.category === 'candles');
const havdalah = shabbatData.items?.find(i => i.category === 'havdalah');

if (candles && havdalah) {
  const shabbatStart = new Date(candles.date);
  const shabbatEnd = new Date(havdalah.date);
  if (now >= shabbatStart && now <= shabbatEnd) {
    return [];
  }
}

// Check holidays (Yom Tov)
if (holidayData.items) {
  const today = now.toISOString().split('T')[0];
  const isYomTov = holidayData.items.some(item =>
    item.yomtov === true && item.date.startsWith(today)
  );
  if (isYomTov) {
    return [];
  }
}

return $input.all();

Holiday HTTP Request node configuration:

Method: GET
URL: https://www.hebcal.com/hebcal
Query Parameters:
  v: 1
  cfg: json
  year: now
  month: now
  maj: on
  mod: on

Workflow structure:

Schedule Trigger -> [Shabbat Check HTTP] -> [Holiday Check HTTP] -> [Gate Code] -> rest of workflow
                    (parallel)              (parallel)

Optimization: Run both HTTP requests in parallel using n8n's split/merge pattern, then feed both results into the Gate Code node.

Pattern 4: Friday Early Cutoff

For workflows that should stop before Shabbat on Friday (e.g., stop processing orders 2 hours before candle lighting).

const now = new Date();
const data = $input.first().json;

const candles = data.items?.find(i => i.category === 'candles');

if (candles) {
  const candleLighting = new Date(candles.date);
  // Stop 2 hours before candle lighting
  const cutoff = new Date(candleLighting.getTime() - 2 * 60 * 60 * 1000);

  if (now >= cutoff) {
    return [];
  }
}

return $input.all();

Use case: E-commerce order processing that should not start new fulfillment workflows close to Shabbat, because they cannot be completed before candle lighting.

Pattern 5: Post-Shabbat Resume

For workflows that should run as soon as Shabbat ends (e.g., send queued notifications after havdalah).

Schedule Trigger cron expression: */15 17-20 * * 6 (every 15 minutes, 5-8 PM on Saturday)

const now = new Date();
const data = $input.first().json;

const havdalah = data.items?.find(i => i.category === 'havdalah');

if (havdalah) {
  const shabbatEnd = new Date(havdalah.date);
  // Only proceed if we are within 30 minutes after havdalah
  const window = new Date(shabbatEnd.getTime() + 30 * 60 * 1000);

  if (now >= shabbatEnd && now <= window) {
    return $input.all(); // Shabbat just ended, process queued items
  }
}

return []; // Not the right time

Pattern 6: Monthly with Holiday Offset

For workflows that run on a specific day each month but shift when that day falls on Shabbat or a holiday.

const now = new Date();
const targetDay = 1; // 1st of each month
const currentDay = now.getDate();

// Check if today is the target day or a postponed run
const shabbatData = $input.first().json;
const candles = shabbatData.items?.find(i => i.category === 'candles');
const havdalah = shabbatData.items?.find(i => i.category === 'havdalah');

let isShabbat = false;
if (candles && havdalah) {
  const start = new Date(candles.date);
  const end = new Date(havdalah.date);
  isShabbat = now >= start && now <= end;
}

if (currentDay === targetDay && !isShabbat) {
  return $input.all(); // Run on target day if not Shabbat
}

if (currentDay === targetDay + 1 || currentDay === targetDay + 2) {
  // Check if the target day was Shabbat/holiday and this is the first valid day
  // This requires checking the previous days, which is more complex
  // Simplified: run on the next valid day after target
  if (!isShabbat) {
    return $input.all();
  }
}

return []; // Not time to run

Caching Shabbat Data

To avoid calling Hebcal on every schedule trigger tick, cache the weekly Shabbat times:

const staticData = $getWorkflowStaticData('global');
const now = Date.now();
const ONE_DAY = 24 * 60 * 60 * 1000;

if (staticData.shabbatData && staticData.fetchedAt > now - ONE_DAY) {
  // Use cached data
  return [{ json: staticData.shabbatData }];
}

// Fetch fresh data (pass to next HTTP Request node)
return $input.all();

After the HTTP Request, store the result:

const staticData = $getWorkflowStaticData('global');
staticData.shabbatData = $input.first().json;
staticData.fetchedAt = Date.now();
return $input.all();

Major Jewish Holidays Reference

Holidays where yomtov: true (work restrictions apply, treat like Shabbat):

Note: Israeli holidays follow Israel schedule (not diaspora), so Sukkot and Pesach have fewer Yom Tov days than outside Israel.

Common Mistakes

1. Using fixed Shabbat times. Shabbat timing varies by 1+ hour throughout the year in Israel (earliest candle lighting ~4:00 PM in December, latest ~7:45 PM in June). Always use the Hebcal API for current times.

2. Forgetting Erev holidays. Some holidays start at sundown the day before (like Shabbat). If your workflow runs Friday afternoon, it needs to check both Shabbat and any holiday that starts Friday night.

3. Not handling DST transitions. Israel switches to summer time (IDT, UTC+3) on the Friday before the last Sunday of March, and back to winter time (IST, UTC+2) on the last Sunday of October. A schedule trigger at "9 AM" will fire at a different UTC time after the transition. Ensure GENERIC_TIMEZONE=Asia/Jerusalem is set so n8n handles this automatically.

4. Hardcoding a single city. If your business serves customers across Israel, candle lighting times can differ by 10+ minutes between cities. Jerusalem is especially different due to the tradition of lighting 40 minutes before sunset (vs 18 minutes in most cities, 30 minutes in Haifa and Zikhron Ya'akov). Choose the earliest candle lighting time among your relevant cities for the safest cutoff.

5. Ignoring Chol HaMoed. The intermediate days of Sukkot and Pesach (Chol HaMoed) are not full Yom Tov, but many Israeli businesses operate on reduced hours. If your workflow involves customer-facing operations, consider pausing or reducing frequency during Chol HaMoed as well.

Webhook Authentication Patterns for n8n

This reference covers HMAC signature verification and JWT claim validation patterns for n8n Webhook nodes processing Israeli payment-gateway and form-submission callbacks. See SKILL.md Step 5 for the higher-level decision table on auth modes.

Auth mode picker

After CVE-2026-21858 (Ni8mare), the "None" mode on a publicly-routable webhook is effectively a vulnerability. Pick one of the other three for every payment-gateway flow.

HMAC signature verification (Cardcom, Grow, custom integrations)

n8n does NOT have a built-in HMAC verifier. Implement it in a Code node directly after the Webhook:

const crypto = require('crypto');
const signature = $input.first().headers['x-signature']; // or x-cardcom-signature etc.
const rawBody = JSON.stringify($input.first().body); // or $input.first().rawBody if exposed
const secret = $env.WEBHOOK_HMAC_SECRET;
const expected = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');

// Timing-safe compare to avoid signature leak via response timing
const a = Buffer.from(signature || '', 'hex');
const b = Buffer.from(expected, 'hex');
if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
  throw new Error('Invalid HMAC signature');
}
return $input.all();

Notes:

• Use crypto.timingSafeEqual, not ===, to avoid leaking the signature via response-time differences.
• Both Buffers must be the same length, otherwise timingSafeEqual throws; the explicit length check handles that.
• If $input.first().rawBody is not exposed in your n8n version, capturing the raw body may require a small middleware or reverse-proxy header (e.g. nginx mirror).

JWT claim validation (caveat)

n8n's JWT Auth credential validates the signature but does NOT auto-check exp, iss, or aud claims. If you need claim validation, decode the token in a Code node and verify each claim explicitly:

const token = $input.first().headers.authorization?.replace(/^Bearer\s+/i, '');
if (!token) throw new Error('Missing token');

const [, payloadB64] = token.split('.');
const payload = JSON.parse(Buffer.from(payloadB64, 'base64url').toString());

const now = Math.floor(Date.now() / 1000);
if (payload.exp && payload.exp < now) throw new Error('Token expired');
if (payload.iss !== $env.EXPECTED_ISSUER) throw new Error('Bad iss');
if (payload.aud !== $env.EXPECTED_AUDIENCE) throw new Error('Bad aud');

return $input.all();

Without this step, an expired token will still pass through n8n's JWT Auth.

IP whitelisting

Cardcom and Tranzila require your webhook server's IP to be whitelisted in their dashboards. If self-hosting n8n, use a static IP or configure a reverse proxy with a fixed egress IP.

תהליכי עבודה n8n בעברית

הנחיות

שלב 1: זיהוי תבנית האוטומציה

לפני שבונים משהו, מתאימים את הצורך העסקי לתבנית n8n מתאימה:

איך בוחרים:

• אם התהליך רץ לפי לוח זמנים, מתחילים עם Schedule Trigger ובודקים אם צריך השהיה בשבת/חגים (שלב 4)
• אם התהליך מגיב לאירועים חיצוניים (אישור תשלום, הגשת טופס), מתחילים עם Webhook trigger
• אם התהליך מעבד טקסט בעברית, מוסיפים Code node בתחילת הצינור לטיפול בקידוד ו-RTL (שלב 3)
• אם התהליך צריך סיווג או סיכום חכם, משתמשים ב-AI Agent node (שלב 7)

שלב 2: חיבור API ישראליים ב-n8n

Morning (חשבונית ירוקה) API

Morning (לשעבר חשבונית ירוקה, Green Invoice) משתמש ב-API key + secret לקבלת JWT token. זה לא OAuth2. הגדרת HTTP Request node:

Method: POST
URL: https://api.greeninvoice.co.il/api/v1/account/token
Headers:
  Content-Type: application/json
Body:
{
  "id": "{{$env.GREEN_INVOICE_API_KEY}}",
  "secret": "{{$env.GREEN_INVOICE_API_SECRET}}"
}

התגובה מכילה JWT token שתקף ל-60 דקות. שומרים אותו ומעבירים לבקשות הבאות:

Authorization: Bearer {{$json.token}}

רפורמת החשבוניות 2026 (הורדת סף): חשבוניות מס מעל הסף דורשות מספר הקצאה מרשות המסים. הסף יורד במהלך 2026:

אחרי יצירת מסמך דרך ה-API של Morning, צריך לקרוא לנקודת הקצה של רשות המסים לקבלת מספר הקצאה עבור חשבוניות מזכות. ה-API של Morning מטפל בזה אוטומטית למסמכים שנוצרים דרך הממשק, אבל מסמכים שנוצרים דרך API עשויים לדרוש בקשת הקצאה מפורשת. בנו את בדיקת הסף כמשתנה ב-workflow, לא כמספר קשיח, מאחר שהסף מתוכנן לרדת שוב. בדקו בתיעוד ה-API של Morning לתהליך העדכני.

סכומים בשקלים עשרוניים (לא באגורות). כשיוצרים מסמכים, price: 50 זה 50 ש"ח, לא 50 אגורות. אין צורך להכפיל או לחלק ב-100.

נקודות קצה נפוצות של Morning API:

קודי סוגי מסמכים לשדה type:

למידע מפורט עיינו ב-references/israeli-api-endpoints.md.

EZCount (EasyCount) API

EZCount (נכתב גם EasyCount) הוא חלופה פופולרית ל-Morning לעוסקים קטנים. ה-API למסמכים הוא REST עם payload JSON, אימות דרך api_key + api_email בגוף הבקשה (לא OAuth, לא Bearer).

Method: POST
URL: https://api.ezcount.co.il/api/createDoc
Headers:
  Content-Type: application/json
Body:
{
  "api_key": "{{$env.EZCOUNT_API_KEY}}",
  "api_email": "{{$env.EZCOUNT_API_EMAIL}}",
  "developer_email": "you@example.com",
  "type": 320,
  "customer_name": "שם הלקוח",
  "customer_email": "client@example.com",
  "item": [{ "details": "שירותי ייעוץ", "amount": 1, "price": 500, "vat_type": "INC" }]
}

קודי סוגי מסמכים תואמים לקודי רשות המסים שבהם משתמש Morning (305 / 320 / 330 / 400). כמו ב-Morning, הסכומים בשקלים עשרוניים, לא באגורות. אותה רפורמת חשבוניות 2026 חלה גם כאן, מעל הסף (10,000 ש"ח עד 31.5.2026, 5,000 ש"ח החל מ-1.6.2026) ה-API שולח אוטומטית לסליקה מול שע"ם ומחזיר את מספר ההקצאה בתגובה. בנו ענף נפילה: אם ה-API מחזיר allocation_status: 'pending', בצעו retry אחרי 30 שניות לפני שאתם מסמנים את החשבונית כסופית.

EZCount ו-Morning מפיקים את אותו פלט משפטי (חשבוניות מס מסולקות), אז הבחירה ביניהם תפעולית ולא טכנית. בחרו EZCount אם הלקוח כבר על המערכת החשבונאית של EasyCount, אחרת ל-Morning יש תיעוד API עשיר יותר.

israeli-bank-scrapers דרך Code Node

ל-n8n אין node מובנה לבנקים ישראליים. משתמשים ב-Code node להרצת israeli-bank-scrapers בצורה פרוגרמטית. החבילה היא ספריית Node.js (לא כלי CLI), לכן חייבים להשתמש ב-createScraper():

חשוב: דורש Node.js >= 22.12.0 בסביבת n8n.

// ב-Code node (ב-n8n 2.0: רץ ב-task runner מבודד)
const { createScraper, CompanyTypes } = require('israeli-bank-scrapers');

const scraper = createScraper({
  companyId: CompanyTypes.hapoalim,
  startDate: new Date('2026-01-01'),
  combineInstallments: false,
  showBrowser: false
});

const credentials = {
  username: $env.BANK_USER,
  // פרטי התחברות נשמרים במשתני סביבה של n8n
  userPassword: $env.BANK_PASS
};
const result = await scraper.scrape(credentials);

if (result.success) {
  return result.accounts.flatMap(account =>
    account.txns.map(txn => ({ json: txn }))
  );
} else {
  throw new Error(`Scraping failed: ${result.errorType} - ${result.errorMessage}`);
}

סורקים נתמכים: הפועלים, לאומי, דיסקונט, מזרחי, אוצר החייל, בינלאומי, מסד, יהב, ביחד משכנתאות, oneZero, בהצדעה, ויזה כאל, מקס (לשעבר לאומי קארד), ישראכרט, אמקס, מרכנתיל.

חסימת Cloudflare (2026): מתחילת 2026, Cloudflare חוסם דפדפנים headless באתרי אמקס וישראכרט. הפורק המתוחזק @sergienko4/israeli-bank-scrapers משתמש ב-Camoufox כפתרון עוקף. אם נתקלים בכשלונות סריקה מתמשכים עם ספקים אלה:

npm install @sergienko4/israeli-bank-scrapers

אבטחה: פרטי התחברות נשמרים ב-credential store של n8n, לא בתוך ה-workflow JSON. משתמשים במשתני סביבה לערכים רגישים.

data.gov.il CKAN API

נתונים פתוחים של ממשלת ישראל דרך CKAN API:

GET https://data.gov.il/api/3/action/datastore_search
Parameters:
  resource_id: <resource-guid>
  q: <search-term>
  limit: 100
  offset: 0

מזהי משאבים שימושיים:

ה-API מחזיר שמות שדות בעברית. משתמשים ב-Code node לנרמול המפתחות לאנגלית לפני עיבוד המשך.

שערי SMS ישראליים

דוגמת 019 Telzar SMS ב-HTTP Request node:

Method: POST
URL: https://019sms.co.il/api
Headers:
  Content-Type: application/json
  Authorization: Bearer {{$env.SMS_019_TOKEN}}
Body:
{
  "from": "MyBusiness",
  "to": "{{$json.phone}}",
  "message": "{{$json.text}}"
}

פורמט מספרי טלפון ישראליים: תמיד שולחים בפורמט בינלאומי 972XXXXXXXXX (מורידים את ה-0 הפותח). Code node לפני ה-SMS node מטפל בזה:

const phone = $input.first().json.phone;
const cleaned = phone.replace(/[-\s]/g, '');
const formatted = cleaned.startsWith('0')
  ? '972' + cleaned.slice(1)
  : cleaned.startsWith('+972')
    ? cleaned.slice(1)
    : cleaned;
return [{ json: { ...$input.first().json, phone: formatted } }];

שלב 3: טיפול בנתונים בעברית ב-n8n

טקסט RTL ב-Code Nodes

ב-n8n צמתי Code מעבדים מחרוזות כ-UTF-8, אז עברית עובדת באופן טבעי. הבעיות מופיעות בממשקים: תגובות API, ייצוא CSV, תבניות מייל.

פורמט מטבע שקלים

Code node לעיצוב סכומים בשקלים:

function formatNIS(amount) {
  return new Intl.NumberFormat('he-IL', {
    style: 'currency',
    currency: 'ILS',
    minimumFractionDigits: 2
  }).format(amount);
}

// קלט:  12345.60
// פלט: 12,345.60 ₪

לגבי Morning API: סכומים ב-API הם בשקלים עשרוניים (לא אגורות). price: 50 זה 50.00 ש"ח. אין צורך להמיר אגורות לשקלים כשעובדים עם Morning API.

פרסור תאריכים ישראליים

מסמכים ישראליים משתמשים בפורמט DD/MM/YYYY. חשוב לפרסר נכון:

// פרסור תאריך ישראלי DD/MM/YYYY
function parseIsraeliDate(dateStr) {
  const [day, month, year] = dateStr.split('/').map(Number);
  return new Date(year, month - 1, day);
}

// פרסור שמות חודשים בעברית (נפוץ במסמכי ממשלה)
const hebrewMonths = {
  'ינואר': 0, 'פברואר': 1, 'מרץ': 2, 'אפריל': 3,
  'מאי': 4, 'יוני': 5, 'יולי': 6, 'אוגוסט': 7,
  'ספטמבר': 8, 'אוקטובר': 9, 'נובמבר': 10, 'דצמבר': 11
};

שלב 4: תזמון מותאם שבת

תהליכים עסקיים בישראל לא צריכים לרוץ בשבת (כניסת שבת ביום שישי עד מוצאי שבת) ובחגים. ל-Schedule Trigger node של n8n אין תמיכה מובנית בזה, אז בונים צומת בדיקה בתחילת כל תהליך מתוזמן.

ארכיטקטורה: Schedule Trigger -> HTTP Request (Hebcal) -> IF (שבת?) -> המשך או עצירה

קריאה ל-Hebcal API ב-HTTP Request node:

GET https://www.hebcal.com/shabbat?cfg=json&geonameid=293397&M=on

geonameid=293397 זה תל אביב. ערים נפוצות נוספות:

Code node לבדיקה אם הזמן הנוכחי נופל בתוך שבת:

const now = new Date();
const shabbatData = $input.first().json;

const candleLighting = shabbatData.items.find(
  item => item.category === 'candles'
);
const havdalah = shabbatData.items.find(
  item => item.category === 'havdalah'
);

if (candleLighting && havdalah) {
  const shabbatStart = new Date(candleLighting.date);
  const shabbatEnd = new Date(havdalah.date);

  if (now >= shabbatStart && now <= shabbatEnd) {
    return []; // פלט ריק עוצר את התהליך
  }
}

return $input.all(); // ממשיך את התהליך

לחגים יהודיים, שאילתה ל-Hebcal holidays API:

GET https://www.hebcal.com/hebcal?v=1&cfg=json&year=now&month=now&maj=on&mod=on

מסננים פריטים עם yomtov: true שבהם חלות מגבלות עבודה (כמו שבת).

למידע מפורט עיינו ב-references/shabbat-cron-patterns.md.

שלב 5: Webhooks של שערי תשלום ישראליים

שערי תשלום ישראליים שולחים תוצאות עסקאות דרך webhooks. מגדירים Webhook nodes ב-n8n לקליטה ועיבוד.

Cardcom

Cardcom שולח POST עם נתונים בפורמט form-encoded:

שדות מפתח ב-callback של Cardcom:

Code node לוולידציה אחרי ה-Webhook:

const data = $input.first().json;

if (data.ReturnValue !== '0') {
  return [{
    json: {
      success: false,
      error: data.DealResponse,
      cardcomId: data.InternalDealNumber
    }
  }];
}

return [{
  json: {
    success: true,
    transactionId: data.InternalDealNumber,
    amount: parseFloat(data.Sum),
    installments: parseInt(data.NumOfPayments),
    customerId: data.CardOwnerID
  }
}];

Cardcom API v11: לאינטגרציות חדשות, מגדירים את ה-webhook URL דרך Cardcom API v11 (https://secure.cardcom.solutions/api/v11) במקום לוח הבקרה הישן. נקודת ה-v11 גם מאפשרת רישום webhooks לאירועי יצירת מסמכים (קבלות, חשבוניות) בנוסף לקריאות חיוב. ה-webhook חייב להיות HTTPS וזמין לאינטרנט (לא localhost, השתמשו ב-ngrok או Cloudflare Tunnel בפיתוח). תיעוד מלא: https://secure.cardcom.solutions/api/v11/DOCS.

Tranzila

Tranzila משתמש בתבנית callback עם פרמטרי GET:

Tranzila API v2: Tranzila מציעה אינטגרציית server-to-server (SAQ-D) פלוס iframe ושדות מתארחים לציות PCI. אימות דרך header בשם X-tranzila-api-app-key (לא Basic Auth, לא פרמטרי query). ה-v2 API תומך בתשלומי ביט, טוקניזציה, חיוב חוזר, החזרים, ו-3D Secure (חובה לכרטיסי אשראי ישראליים לפי כללי שב"א). לאינטגרציות חדשות, עדיף v2 על פני התבנית הישנה tranzila71dl.cgi. זרימת ביט: השרת קורא ל-Tranzila v2, התגובה כוללת URL להטמעה ב-iframe (שמציג קוד QR וטלפון להתראת push). תיעוד: https://docs.tranzila.com/.

Grow by Meshulam

Grow by Meshulam שולח התראות webhook כבקשות POST. חשוב: ה-API של Grow משתמש ב-multipart/form-data לבקשות (לא JSON). אחרי קבלת webhook, חובה לקרוא ל-approveTransaction כדי לסיים את העסקה.

שדות ב-webhook payload:

Code node לעיבוד webhook של Grow ואישור:

const data = $input.first().json;

const payment = {
  transactionCode: data.transactionCode,
  asmachta: data.asmachta,
  amount: parseFloat(data.paymentSum),
  customerName: data.fullName,
  customerPhone: data.payerPhone,
  customerEmail: data.payerEmail,
  installments: parseInt(data.paymentsNum) || 1
};

// חובה לקרוא ל-approveTransaction אחרי קבלת ה-webhook
// זה נעשה ב-HTTP Request node הבא עם multipart/form-data
return [{ json: payment }];

רשימת IP לבנה: Cardcom ו-Tranzila דורשים שה-IP של שרת ה-webhook יהיה ברשימה המורשית בלוח הבקרה שלהם. באירוח עצמי השתמשו ב-IP קבוע או reverse proxy עם כתובת יציאה קבועה.

תשלומי ביט

ביט הוא אמצעי התשלום הנייד הפופולרי ביותר בישראל. תשלומי ביט זמינים דרך Tranzila (API v2) ו-Grow by Meshulam, לא כ-API עצמאי.

ביט דרך Tranzila v2: יוצרים דף תשלום עם bit: true בבקשה. הלקוח סורק QR או מופנה לביט. ה-webhook callback משתמש באותם שדות כמו עסקאות כרטיס אשראי.

ביט דרך Grow by Meshulam: מפעילים ביט בלוח הבקרה של Grow. עסקאות ביט מופיעות באותו תהליך webhook כמו עסקאות כרטיס, עם ערך transactionType שונה.

אופני אימות ל-Webhook

צומת Webhook של n8n תומך בארבעה אופני אימות. אחרי שרשרת ה-CVE של Ni8mare, "None" על webhook ציבורי הוא למעשה פרצת אבטחה. בכל זרימת תשלום או טופס ציבורי בחרו אחד מהשלושה האחרים:

אימות חתימת HMAC (Cardcom, Grow, אינטגרציות מותאמות): ל-n8n אין מאמת HMAC מובנה. ממשים אותו ב-Code node מיד אחרי ה-Webhook:

const crypto = require('crypto');
const signature = $input.first().headers['x-signature']; // או x-cardcom-signature וכו'
const rawBody = JSON.stringify($input.first().body);
const secret = $env.WEBHOOK_HMAC_SECRET;
const expected = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');

// השוואה בטוחה מבחינת זמן כדי לא להדליף את החתימה דרך timing
const a = Buffer.from(signature || '', 'hex');
const b = Buffer.from(expected, 'hex');
if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
  throw new Error('Invalid HMAC signature');
}
return $input.all();

הסתייגות JWT: ה-JWT Auth של n8n מאמת חתימה אבל לא בודק exp, iss או aud. אם צריך אימות claims, הוסיפו Code node אחרי ה-Webhook שמפענח את הטוקן ומאמת כל claim, אחרת טוקן שפג תוקף יעבור.

שלב 6: שיקולי אירוח עצמי

שינויים משמעותיים ב-n8n 2.0 (דצמבר 2025) + עדכוני אבטחה (2026)

n8n 2.0 שוחרר בדצמבר 2025; הקו היציב נמצא על 2.x (2.21.x נכון למאי 2026, בטא על 2.22.0, עם minor חדש כמעט כל שבוע). נעלו תג ספציפי בפרודקשן במקום n8nio/n8n:latest.

טלאי אבטחה קריטי, חובה לעבור ל-2.10.1 לפחות: CVE-2026-21858 ("Ni8mare", CVSS 10.0) הוא RCE לא מאומת דרך webhook/form, פורסם בינואר 2026 ותוקן ב-1.121.0 וב-2.10.1. צמד חולשות נוסף ממרץ 2026 (CVE-2026-27493 + CVE-2026-27577) מאפשר RCE על השרת במחשב מארח בגרסאות 2.10.1>, 2.9.3>, 1.123.22> ותוקן ב-2.10.1 / 2.9.3 / 1.123.22. אם ה-workflow חושף Webhook ציבורי (כל זרימת תשלום בסקיל הזה חושפת), חובה להריץ 2.10.1 ומעלה, רצוי על 2.21.x הנוכחי. נעלו את התג ב-docker-compose.yml ועקבו אחרי פיד אבטחה של n8n.

n8n 2.0 הביא שינויים משמעותיים שמשפיעים על תהליכים ישראליים:

ב-n8n 2.0, צומת Execute Command (וגם Local File Trigger) נוסף לרשימת NODES_EXCLUDE של ברירת המחדל, ולכן הוא נעלם מלוח הצמתים. כדי להפעיל מחדש את Execute Command, דורסים את NODES_EXCLUDE כך שלא יכיל את n8n-nodes-base.executeCommand, הדריסה הפשוטה ביותר היא רשימה ריקה, ואז מפעילים מחדש את n8n:

NODES_EXCLUDE=[]

לפי תיעוד השינויים של n8n 2.0 זה המנגנון הנתמך, אין משתנה N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE. הפעלת Execute Command מאפשרת לכל מי שיש לו הרשאת עריכת workflow להריץ פקודות shell שרירותיות, אז עשו זאת רק בסביבות מהימנות וחד-משתמש. הגישה המומלצת נשארת מעבר ל-Code nodes.

אפשרויות ענן ישראליות

ציות לרגולציית מיקום נתונים: הרשות להגנת הפרטיות (PPA) לא דורשת שכל המידע יישאר בישראל. היא מגבילה העברת מידע אישי למדינות ללא הגנה מספקת, או דורשת אמצעי הגנה נוספים (כמו סעיפים חוזיים). לתהליכים שמעבדים מידע אישי (תעודות זהות, פרטי בנק, מידע רפואי), יש לבחור ספק עם מרכז נתונים בישראל או לוודא שמדינת היעד ברשימה המאושרת של הרשות.

Docker Compose לאירוח עצמי

services:
  n8n:
    # נועלים תג ספציפי. אסור :latest בפרודקשן.
    # חייב להיות לפחות 2.10.1 כדי להיות מטולא נגד CVE-2026-21858 (Ni8mare).
    image: n8nio/n8n:2.21.4
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://${N8N_HOST}/
      - GENERIC_TIMEZONE=Asia/Jerusalem
      - TZ=Asia/Jerusalem
      # מומלץ: רוטציה של מפתח ההצפנה רק דרך תהליך המיגרציה המתועד.
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:

הערות:

• n8n 1.0 ומעלה משתמש בניהול משתמשים מובנה (אימייל + סיסמה). משתני הסביבה הישנים N8N_BASIC_AUTH_* הוסרו. בהפעלה ראשונה, n8n מבקש ליצור חשבון בעלים.
• version: '3.8' לא מופיע כי הוא מיושן ב-Docker Compose V2.
• קריטי: חובה להגדיר GENERIC_TIMEZONE=Asia/Jerusalem ו-TZ=Asia/Jerusalem. בלי זה, כל ה-Schedule Trigger nodes רצים לפי UTC, וחישובי שבת יהיו מוזזים ב-2-3 שעות (ישראל ב-UTC+2 בחורף, UTC+3 בקיץ). שעון קיץ בישראל מתחיל ביום שישי שלפני יום ראשון האחרון של מרץ ומסתיים ביום ראשון האחרון של אוקטובר.

שלב 7: צמתי AI Agent של n8n לתהליכים ישראליים

n8n 2.x מגיע עם אינטגרציית LangChain מובנית (קבוצת הצמתים "Advanced AI"). מעל 70 צמתי AI: Tools Agent, Conversational Agent, צמתי זיכרון (Window Buffer, Summary Buffer), צמתי Vector Store ל-RAG (Pinecone, Qdrant, Supabase pgvector), וצמתי Model עבור OpenAI (GPT-4o), Anthropic (Claude 3.5 Sonnet, Claude Opus 4.7 עם מצב חשיבה דינמי), ומודלים מקומיים דרך Ollama. כלים חזקים לאוטומציה עסקית ישראלית.

בחירת מודל לתוכן ישראלי:

RAG על תוכן ישראלי (צמתי Vector Store): מחברים צומת Vector Store (Pinecone, Qdrant או Supabase pgvector) ל-AI Agent כדי לבצע retrieval על קורפוסים בעברית (היסטוריית חשבוניות, PDF של חוקי מס, יומני צ'אט לקוחות). השתמשו במודל embedding רב-לשוני שמטפל בעברית (Cohere embed-multilingual-v3.0 או OpenAI text-embedding-3-large); ברירת המחדל text-embedding-ada-002 חלשה בעברית לעומת שפות בכתב לטיני.

דוגמה: סיווג אוטומטי של תנועות בנק עם AI

ארכיטקטורה: Schedule Trigger -> Code (סריקת בנק) -> AI Agent (סיווג) -> Google Sheets

// Code node: הכנת תנועות לסיווג AI
const transactions = $input.all().map(item => ({
  json: {
    date: item.json.date,
    description: item.json.description,
    amount: item.json.chargedAmount,
    prompt: `סווג את תנועת הבנק הישראלית הזו למטרות הנהלת חשבונות.
תנועה: "${item.json.description}" על סך ${item.json.chargedAmount} ש"ח בתאריך ${item.json.date}.
קטגוריות: הכנסות, שכר, ספקים, מע"מ, ביטוח לאומי, שכירות, הוצאות משרד, אחר.
השב עם שם הקטגוריה בלבד.`
  }
}));
return transactions;

מחברים את הפלט של ה-Code node ל-AI Agent node (Tools Agent) שמוגדר עם ה-LLM המועדף. הסוכן מסווג כל תנועה לפי התיאור העברי וקטגוריות ההוצאות הישראליות המוכרות.

אינטגרציית MCP ב-n8n (שני צמתים): n8n 2.x מגיע עם שני צמתי MCP מובנים:

• MCP Client Tool (@n8n/n8n-nodes-langchain.toolMcp): מתחבר כצומת משנה ל-AI Agent כך שהסוכן יקרא לכלים שחשופים בשרת MCP חיצוני. שימושי לחיבור שרתי MCP מ-agentskills.co.il כמו hebcal, israeli-bank או data-gov-il לסוכנים שלכם.
• MCP Server Trigger: חושף תהליך n8n כשלעצמו ככלי MCP. לקוחות AI חיצוניים (Claude Desktop, Cursor, Windsurf, GPT מותאמים) יכולים לגלות ולהפעיל את התהליך כאילו הוא כלי native. שימושי לעטיפת תהליך חיפוש חשבוניות Morning או סורק בנק כך שכל עוזר AI במשרד יוכל להפעיל אותו לפי דרישה.

ביחד הצמתים האלה הופכים את n8n גם למארח כלים וגם לצרכן כלים בסטאק סוכני מבוסס MCP.

שלב 8: מתי להשתמש ב-n8n לעומת חלופות

בחרו n8n כש: צריכים אירוח עצמי למיקום נתוני ישראל, אוטומציות ללא הגבלה, גישה מלאה לקוד לטיפול ב-API ישראליים (קידוד עברית, פורמט טלפונים, חישובי מע"מ), או יכולות AI Agent עם הקשר ישראלי.

שלב 9: ייבוא וייצוא של workflow כ-JSON

תהליכי n8n הם מסמכי JSON. סוכנים שבונים תהליכים בצורה פרוגרמטית (במקום ללחוץ בממשק) חייבים להבין את המבנה:

{
  "name": "Morning daily reconciliation",
  "nodes": [
    {
      "parameters": { "rule": { "interval": [{ "field": "cronExpression", "expression": "0 6 * * 0-4" }] } },
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [240, 300]
    }
  ],
  "connections": {
    "Schedule Trigger": { "main": [[{ "node": "Get Token", "type": "main", "index": 0 }]] }
  }
}

מבנה עיקרי:

• `nodes`: מערך של אובייקטי צמתים. לכל אחד name (ייחודי, משמש כמפתח חיבור), type (למשל n8n-nodes-base.httpRequest), typeVersion (חייב להתאים לגרסה ש-n8n תומך בה, אחרת הייבוא נכשל), parameters (הגדרות הצומת) ו-position (קואורדינטות [x, y]).
• `connections`: אובייקט שממופתח לפי name של צומת המקור, וממפה פלט (main) למערך של מערכים של יעדים { node, type, index }. המערך הכפול מאפשר פלטים מרובים (למשל ענפי צומת IF).
• ייצוא דרך הממשק ("Download") או GET /api/v1/workflows/{id}; ייבוא דרך "Import from File" או POST /api/v1/workflows. אחרי ייבוא ל-n8n 2.0 חובה לפרסם את התהליך לפני שהוא רץ. ערכי typeVersion משתנים בין גרסאות, לכן בנו JSON מול גרסת n8n ידועה.

שלב 10: הגדרת credentials ל-API ישראליים

n8n שומר סודות ב-credential store מוצפן, לעולם לא בתוך ה-workflow JSON:

• JWT של Morning (חשבונית ירוקה): אין credential מובנה. משרשרים HTTP Request nodes, הראשון קורא ל-/account/token עם ה-API key וה-secret, הצמתים הבאים שולחים Authorization: Bearer {{token}} דרך Header Auth או ביטוי. הטוקן פג אחרי 60 דקות, אז מרעננים בכל הרצה במקום לשמור אותו לטווח ארוך.
• שערי SMS ישראליים (019, InforUMobile): יוצרים credential מסוג Header Auth, שם Authorization, ערך Bearer <token>, ומצרפים ל-HTTP Request node.
• שערי תשלום (Cardcom, Tranzila, Grow): שומרים מזהי סוחר / מפתחות API כערכי Generic Credential שמופנים דרך {{$credentials.fieldName}}. בקשות ה-multipart/form-data של Grow עדיין שולפות סודות מה-credential, לא מגוף הצומת.
• באירוח עצמי, הגדירו N8N_ENCRYPTION_KEY יציב כדי שה-credential store יישאר ניתן לפענוח בין הפעלות מחדש.

דוגמאות

דוגמה 1: חיבור Morning ל-n8n להתאמת חשבוניות יומית

המשתמש אומר: "כל בוקר תמשוך את חשבוניות Morning של אתמול ותסמן את אלה שעדיין לא שולמו."

צומת אחר צומת: 1. Schedule Trigger: cron 0 6 * * 0-4 (09:00 שעון ישראל חורף, ראשון-חמישי). 2. HTTP Request, "Get Token": POST https://api.greeninvoice.co.il/api/v1/account/token עם { id, secret } מה-credentials. פלט: JWT. 3. HTTP Request, "Search Documents": POST /api/v1/documents/search עם Authorization: Bearer {{$json.token}}, גוף שמסנן fromDate/toDate לאתמול ו-type ל-305/320. 4. צומת IF: מתפצל לפי status (פתוח מול סגור) כדי להפריד חשבוניות שלא שולמו. 5. HTTP Request (SMS) או Send Email: מודיע למנהל החשבונות על חשבוניות שלא שולמו, גוף בעברית עטוף ב-<div dir="rtl">.

עטפו את כל התהליך בבדיקת השבת משלב 4 אם הוא לא אמור לרוץ לעולם בחג שנופל באמצע השבוע.

דוגמה 2: תנועות בנק ל-Google Sheet, מודע לחגים

המשתמש אומר: "תסרוק את חשבון העסק שלי כל לילה ותוסיף תנועות חדשות לגיליון, אבל תדלג על שבת וחגים."

צומת אחר צומת: 1. Schedule Trigger: cron לשעת ערב באמצע השבוע. 2. HTTP Request (Hebcal) + Code (בדיקת שבת) משלב 4: פלט ריק עוצר את ההרצה בשבת/חג. 3. Code node: מריץ israeli-bank-scrapers דרך createScraper() (שלב 2), פריט אחד לכל תנועה. 4. Code node: מנרמל תיאורים בעברית, מעצב סכומים עם Intl.NumberFormat('he-IL', ...), מפרסר תאריכים כ-DD/MM/YYYY. 5. Google Sheets node (Append): כותב שורות לגיליון הנהלת החשבונות. 6. תהליך Error Trigger נפרד תופס הרצה שנכשלה ומתריע (ראו מלכודות נפוצות).

שרתי MCP מומלצים

שרתי ה-MCP הבאים מהדירקטוריה נותנים לצומת AI Agent נתונים ישראליים חיים לפי דרישה:

• hebcal: לוח השנה היהודי וזמני שבת, חלופה לקריאה ל-Hebcal HTTP API בכל תהליך.
• israeli-bank: נתוני חשבונות בנק ישראליים, מאפשר לסוכן למשוך תנועות במקום להריץ israeli-bank-scrapers ב-Code node.
• data-gov-il: נתונים פתוחים של ממשלת ישראל (CKAN), שאילתת מרשמים בלי לבנות HTTP Request nodes ידנית.

קישורי עזר

מלכודות נפוצות

• סוכנים נועלים `n8nio/n8n:latest` או תג ישן של 1.x. גרסאות n8n self-hosted לפני 2.10.1 / 1.121.0 פגיעות לשרשרת ה-RCE של Ni8mare (CVE-2026-21858, CVSS 10.0) פלוס שרשרת CVE-2026-27493 + CVE-2026-27577 של מרץ 2026. כל Webhook ציבורי (כל workflow של שער תשלום בסקיל הזה) הופך את המארח לניתן לניצול. נעלו תג ספציפי של 2.10.1 ומעלה (היציב הנוכחי הוא 2.21.x) ב-Docker Compose ועקבו אחרי פיד אבטחה של n8n.
• סוכנים משתמשים ב-UTC כברירת מחדל ל-schedule triggers. ישראל ב-Asia/Jerusalem (UTC+2/+3), ומעבר לשעון קיץ בישראל קורה בתאריכים שונים מארה"ב ואירופה (שעון קיץ מתחיל ביום שישי שלפני יום ראשון האחרון של מרץ, ומסתיים ביום ראשון האחרון של אוקטובר). תמיד להגדיר GENERIC_TIMEZONE ולוודא אחרי כל מעבר שעון.
• סוכנים מפרמטים תאריכים כ-MM/DD/YYYY. בישראל הפורמט הוא DD/MM/YYYY. כל Code node שמפרסר תאריכים חייב לטפל בזה מפורשות. Morning API מחזיר ISO 8601, אבל מערכות ממשלה מחזירות DD/MM/YYYY כמחרוזות.
• סוכנים שולחים מספרי טלפון ישראליים עם אפס פותח. שערי SMS דורשים פורמט בינלאומי (972XXXXXXXXX). מספר כמו 050-1234567 חייב להפוך ל-972501234567.
• סוכנים מניחים שמע"מ כלול בסכומים. חשבוניות ישראליות מציגות בדרך כלל סכומים לפני מע"מ. Morning API מחזיר גם amount (לפני מע"מ) וגם totalAmount (כולל מע"מ). תמיד לבדוק איזה שדה נדרש. שיעור מע"מ נוכחי: 18% (נכון ל-2026).
• סוכנים מתעלמים מכך שזמני שבת משתנים לפי עיר. הדלקת נרות בירושלים 40 דקות לפני השקיעה, בחיפה וזיכרון יעקב 30 דקות, ובתל אביב וכל שאר הערים 18 דקות. זמן קבוע אחד לכל ישראל יגרום לתהליכים לרוץ בשבת בחלק מהערים.
• Execute Command node מושבת כברירת מחדל ב-n8n 2.0. תהליכים שהשתמשו ב-Execute Command להרצת סקריפטים (למשל לסריקת בנקים) ייכשלו בשקט אחרי שדרוג ל-n8n 2.0. יש לעבור ל-Code nodes, או להפעיל מחדש דרך דריסת משתנה הסביבה NODES_EXCLUDE כך שלא יכיל את n8n-nodes-base.executeCommand (אין משתנה N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE, זו הזיה נפוצה).
• סכומים ב-Morning API הם בשקלים, לא באגורות. ה-API משתמש בשקלים עשרוניים (price: 50 = 50 ש"ח). אין להכפיל ב-100 או לבצע המרות אגורות. זה שונה מכמה שערי תשלום שמשתמשים באגורות.
• רפורמת החשבוניות 2026 משפיעה על אוטומציות, הסף יורד ב-1 ביוני 2026. חשבוניות מס מעל הסף (10,000 ש"ח עד 31 במאי 2026, ואז 5,000 ש"ח החל מ-1 ביוני 2026) שנוצרו דרך API דורשות כעת מספרי הקצאה מרשות המסים. תהליכים שמייצרים חשבוניות אוטומטית חייבים לטפל בשלב ההקצאה, אחרת החשבונית לא תקפה לניכוי מס. שמרו את הסף כמשתנה ב-workflow, לא כמספר קשיח.
• קיצורי המקלדת בעורך של n8n נשברים תחת פריסת מקלדת בעברית. הקנבס קורא את e.key במקום e.code, אז כשמקלדת עברית פעילה Ctrl+C מחזיר e.key = 'ב' והקיצור נכשל. החליפו את שפת הקלט לאנגלית בזמן עריכה, או השתמשו בפעולות מהתפריט. issue 12569 ב-GitHub של n8n.
• לעורך הביטויים והטקסט של n8n אין תמיכה native ב-RTL. טקסט עברי בשדות ביטוי מוצג משמאל לימין, מה שמקשה לקרוא מחרוזות עברית ארוכות ושובר את היישור הויזואלי עם סימני פיסוק סובבים. למחרוזות עברית ליטרליות ארוכות, שמרו אותן במשתני סביבה או ב-static workflow data וקראו להן בשם, במקום להקליד אותן בעורך הביטויים.
• תהליכים לא מנוטרים נכשלים בשקט בלי Error Trigger. סריקת בנק מתוזמנת או סנכרון חשבוניות שזורק שגיאה פשוט נעצר, ואף אחד לא יודע עד שהנתונים מיושנים. צרו תהליך נפרד שמתחיל בצומת Error Trigger (n8n מנתב כל הרצה שנכשלה אליו) ששולח התראה בעברית ל-Slack או SMS. לכשלים זמניים (חסימות Cloudflare, טוקנים שפגו, rate limit) הפעילו גם Retry On Fail ברמת הצומת עם המתנה סבירה, במקום לתת לכל ההרצה למות בכשל הראשון.

משאבים מצורפים

מסמכי עזר

• references/israeli-api-endpoints.md -- טבלת עזר מלאה של נקודות קצה API ישראליות לתהליכי n8n, כולל Morning (חשבונית ירוקה), data.gov.il, שערי SMS, שערי תשלום ו-Hebcal. עיינו בו בעת הגדרת HTTP Request nodes לשירותים ישראליים.
• references/shabbat-cron-patterns.md -- תבניות תזמון מוכנות מראש מותאמות שבת ל-n8n כולל הגדרות שבועיות, חודשיות ומותאמות חגים עם אינטגרציית Hebcal API. עיינו בו בעת הגדרת כל תהליך מתוזמן שצריך לכבד שבת וחגים.

פתרון בעיות

שגיאה: "Morning API מחזיר 401 Unauthorized"

סיבה: ה-JWT token פג תוקף. לטוקנים של Morning יש TTL של 60 דקות. פתרון: הוספת שלב רענון טוקן בתחילת כל הרצת תהליך. שמירת הטוקן ב-static data של n8n ($getWorkflowStaticData('global')) עם חותמת זמן, ורענון אם עבר יותר מ-55 דקות.

שגיאה: "טקסט עברי מופיע משובש בייצוא CSV"

סיבה: ה-CSV חסר BOM (Byte Order Mark) של UTF-8, אז Excel מפרש אותו כ-ANSI. פתרון: ב-Code node שמכין נתוני CSV, מוסיפים BOM בתחילה: '\uFEFF' + csvContent. לחלופין, מגדירים את אפשרות ה-encoding של Spreadsheet File node ל-UTF-8-BOM.

שגיאה: "Webhook לא מקבל callbacks מ-Cardcom"

סיבה: Cardcom דורש שה-callback URL יהיה נגיש מהאינטרנט עם תעודת SSL תקינה. n8n באירוח עצמי מאחורי firewall לא יקבל callbacks. פתרון: שימוש ב-reverse proxy (nginx, Caddy) עם SSL של Let's Encrypt. וידוא שמשתנה הסביבה WEBHOOK_URL תואם ל-URL הציבורי. הוספת ה-IP של n8n לרשימה המורשית בלוח הבקרה של Cardcom.

שגיאה: "Schedule Trigger רץ בשבת למרות בדיקת Hebcal"

סיבה: אזור הזמן של שרת n8n מוגדר ל-UTC במקום Asia/Jerusalem, כך שהשוואת זמני שבת מוסטת ב-2-3 שעות. פתרון: וידוא GENERIC_TIMEZONE=Asia/Jerusalem במשתני הסביבה של n8n. הפעלה מחדש של n8n אחרי שינוי הגדרות אזור זמן. בדיקה על ידי הדפסת new Date().toString() ב-Code node.

שגיאה: "israeli-bank-scrapers נכשל ב-Code node"

סיבה: ב-n8n 2.0, Code nodes רצים ב-task runner מבודד. חבילת israeli-bank-scrapers והתלויות שלה (Puppeteer/Playwright) עשויות לא להיות זמינות ב-sandbox. פתרון: התקנת israeli-bank-scrapers כחבילת npm שנגישה ל-task runner של n8n. וידוא שה-Docker container של n8n מקצה מספיק זיכרון (לפחות 1GB) ל-Chromium.

שגיאה: "Cloudflare חוסם סורק בנקים עבור אמקס/ישראכרט"

סיבה: מתחילת 2026, Cloudflare חוסם דפדפנים headless באתרים פיננסיים ישראליים מסוימים. פתרון: מעבר לפורק המתוחזק @sergienko4/israeli-bank-scrapers שמשתמש ב-Camoufox לעקיפת חסימת Cloudflare. התקנה: npm install @sergienko4/israeli-bank-scrapers.