// QUICK INSTALL

Download, configure, and start your first Organisync mesh in under 10 minutes.

You'll need an active Organisync license. Get one in the portal →

Requirements

Requirement Details
OS Linux — amd64 or arm64 (kernel ≥ 4.18 for inotify)
License organisync.lic signed with your vendor key
Ports Default: TCP 9000 (API transport), TCP 22 (SSH transport)
Disk ≥ 50 MB for binaries + manifests. Cache scales with watched files.

Step-by-step

  • 1
    Download binaries from your customer portal — choose your arch (amd64 / arm64). 
    curl -Lo organisyncd-linux-amd64.tar.gz "https://releases.organisync.net/..."
tar -xzf organisyncd-linux-amd64.tar.gz
sudo mv organisyncd organisync /usr/local/bin/
  • 2
    Place your license file alongside your config (default path /etc/organisync/organisync.lic) or set ORGANISYNC_LICENSE=/path/to/organisync.lic.
  • 3
    Create config at /etc/organisync/config.yaml. Minimal cluster config: 
    environment: production

cluster:
  self:
    id: node-eu-1
    region: EU
    listen: 0.0.0.0:9001
  regions: [EU, US]
  delivery:
    mode: region-min
  peers:
    - id: node-us-1
      region: US
      host: 10.0.2.10:9001
      transport: api

watch:
  entries:
    - dir: /etc/ssl/private
      patterns: ["*.key", "*.pem"]
      default_regions: [EU, US]

storage:
  manifests_dir: /var/lib/organisync/manifests
  cache_dir:     /var/lib/organisync/cache

audit:
  enabled:    true
  log_path:   /var/log/organisync/audit.jsonl
  hash_chain: true

daemon:
  startup_reconciliation: true
  • 4
    Start the daemon: 
    organisyncd --config /etc/organisync/config.yaml
    Systemd unit: 
    [Unit]
Description=Organisync File Distribution Daemon
After=network.target

[Service]
ExecStart=/usr/local/bin/organisyncd --config /etc/organisync/config.yaml
Restart=always
Environment=ORGANISYNC_LICENSE=/etc/organisync/organisync.lic

[Install]
WantedBy=multi-user.target
  • 5
    Verify connectivity: 
    organisync health
#   node-eu-1 (EU): reachable failures=0
#   node-us-1 (US): reachable failures=0

License file location

The daemon checks, in order:

  1. Value of ORGANISYNC_LICENSE env var
  2. /etc/organisync/organisync.lic (default)

If no license file is found the daemon logs a warning and runs in unlicensed (dev) mode — sync continues but audit trail is not bound to a customer ID.

// CONFIG REFERENCE

Full organisyncd.yaml configuration reference.

Top-level keys

Key Type Required Description
environment string required Free-form label (e.g. production)
cluster object required Mesh topology and peer definitions
watch object required Directories and patterns to watch
transport object optional Per-transport tuning (SSH, API, TCP)
sync object optional Concurrency and timeout limits
reconciliation object optional Background reconciliation schedule
health object optional Peer liveness probe settings
storage object required Disk paths for manifests and cache
audit object optional Audit log settings
daemon object optional Daemon behavior (log level, PID file, startup reconcile)

Delivery modes

Mode Description
all Sync must succeed on all peers in all required regions
region-min At least one peer per required region must acknowledge
per-region-count per_region_count peers per region must acknowledge

Transports

Transport Best for Notes
ssh Air-gapped, HSM networks Uses existing SSH key infra. No extra ports.
api Cloud / container meshes HTTPS + bearer token or mTLS. Firewall-friendly.
tcp High-throughput intra-cluster Optional WebSocket upgrade for proxied environments.

Audit log settings

audit:
  enabled:    true
  log_path:   /var/log/organisync/audit.jsonl
  hash_chain: true          # SHA-256 chain linking every entry
  pgp_sign:   false         # Pro+ only: PGP-sign each chain link
  pgp_key_path: ""          # Path to ASCII-armored private key
  log_rotation:
    max_size_mb:  100
    max_age_days: 90
    compress:     true
The customer_id field in every audit entry is bound to your license. Every sync operation is traceable back to the licensed customer.

// CLI REFERENCE

All organisync CLI subcommands.

Subcommands

Command Description
push <file> [--regions R1,R2] Push a file to target region peers
verify <file> Show manifest, sync history, and pending regions for a file
reconcile [--file <path>] Trigger full or file-scoped reconciliation
tombstones --report List tombstoned (deleted) files and their age
tombstones --cleanup [--confirm|--dry-run] Prune tombstones; default is dry-run
audit --since <duration> Tail audit log (e.g. --since 24h)
health Show all peer states, failure counts, and config drift
config --validate Validate config and print fingerprint
license keygen Generate Ed25519 vendor keypair (vendor builds only)
license generate Sign a .lic file for a customer (vendor builds only)
infra deploy [--env] [--layer] Apply Terragrunt layers via CLI wrapper

// ENTERPRISE SDK

The Organisync Go SDK is a thin HTTP client for embedding Organisync sync operations in your own Go applications. Available on Enterprise tier. Download from your customer portal.

Enterprise only. The SDK is gated on capabilities.sdk_access = true in your license. Upgrade to Enterprise →

Install

# Download organisync-sdk-v*.tar.gz from the portal
tar -xzf organisync-sdk-v1.0.0.tar.gz
# Move to your Go module vendor or GOPATH
go get ./...

Quickstart

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/yourorg/organisync-sdk/org"
)

func main() {
    c, err := org.NewClient(org.Config{
        DaemonURL: "http://localhost:9001", // local organisyncd API
        Token:     "your-bearer-token",    // from config.yaml api.auth.token_path
    })
    if err != nil {
        log.Fatal(err)
    }

    // Push a file to EU and US regions
    result, err := c.Push(context.Background(), org.PushRequest{
        FilePath: "/etc/ssl/certs/my-cert.pem",
        Regions:  []string{"EU", "US"},
    })
    if err != nil {
        log.Fatalf("push failed: %v", err)
    }
    fmt.Printf("push status: %s (took %s)\n", result.Status, result.Duration)
}

SDK API Reference

Method Description
NewClient(Config) (*Client, error) Create a new SDK client. Validates connectivity.
Push(ctx, PushRequest) (*PushResult, error) Push file to target regions. Blocks until delivery confirmed.
Verify(ctx, path) (*Manifest, error) Return the manifest and sync history for a path.
Reconcile(ctx, path) error Trigger reconciliation for a single file or all files (empty path).
Health(ctx) ([]PeerState, error) Return liveness state of all configured peers.
The SDK communicates exclusively via the local organisyncd API — it contains no Organisync business logic. Core sync, verification, and audit logic remains in the compiled daemon binary.