Build with ThreadSync

# 1. Authenticate and get your token
curl -X POST https://api.threadsync.io/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"client_id": "YOUR_CLIENT_ID", "client_secret": "YOUR_SECRET"}'

# 2. Connect to Salesforce (source)
curl -X POST https://api.threadsync.io/v1/connections \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"provider": "salesforce"}'

# 3. Connect to Snowflake (destination)
curl -X POST https://api.threadsync.io/v1/connections \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"provider": "snowflake"}'

# 4. Sync contacts to your data warehouse
# Use the connection IDs returned from steps 2 and 3
curl -X POST https://api.threadsync.io/v1/syncs \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {"connection": "SF_CONNECTION_ID", "object": "Contact"},
    "destination": {"connection": "SNOWFLAKE_CONNECTION_ID", "table": "contacts"},
    "schedule": "realtime"
  }'

import { ThreadSync } from '@threadsync/sdk';

// Initialize the client
const ts = new ThreadSync({
  bearerToken: process.env.THREADSYNC_API_TOKEN
});

async function main() {
  // Connect to Salesforce
  const sf = await ts.connections.create('salesforce');

  // Connect to your data warehouse
  const dest = await ts.connections.create('snowflake');

  // Sync contacts in real-time
  const sync = await ts.sync.create({
    source: { connection: sf.id, object: 'Contact' },
    destination: { connection: dest.id, table: 'contacts' },
    schedule: 'realtime'
  });

  // Check sync status
  const status = await ts.sync.get(sync.id);
  console.log(`Synced ${status.recordsSynced} records`);
}

main();

import os
from threadsync import ThreadSync

# Initialize the client
ts = ThreadSync(bearer_token=os.environ["THREADSYNC_API_TOKEN"])

# Connect to Salesforce
sf = ts.connections.create(provider="salesforce")

# Connect to your data warehouse
dest = ts.connections.create(provider="snowflake")

# Create a real-time sync
sync = ts.sync.create(
    source={"connection": sf.id, "object": "Contact"},
    destination={"connection": dest.id, "table": "contacts"},
    schedule="realtime"
)

# Check sync status
status = ts.sync.get(sync.id)
print(f"Synced {status.records_synced} records")

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/threadsync-infrastructure/threadsync-go"
)

func main() {
    // Initialize the client
    client := threadsync.New(os.Getenv("THREADSYNC_API_TOKEN"))

    // Connect to Salesforce
    sf, err := client.Connections.Create("salesforce", nil)
    if err != nil { log.Fatal(err) }

    // Connect to your data warehouse
    dest, err := client.Connections.Create("snowflake", nil)
    if err != nil { log.Fatal(err) }

    // Create a real-time sync
    sync, err := client.Sync.Create(&threadsync.SyncConfig{
        Source:      threadsync.Endpoint{Connection: sf.ID, Object: "Contact"},
        Destination: threadsync.Endpoint{Connection: dest.ID, Table: "contacts"},
        Schedule:    "realtime",
    })
    if err != nil { log.Fatal(err) }

    fmt.Printf("Sync created: %s\n", sync.ID)
}

import io.threadsync.sdk.ThreadSync;
import io.threadsync.sdk.models.*;

public class QuickStart {
    public static void main(String[] args) {
        // Initialize the client
        ThreadSync ts = ThreadSync.builder()
            .bearerToken(System.getenv("THREADSYNC_API_TOKEN"))
            .build();

        // Connect to Salesforce
        Connection sf = ts.connections()
            .create("salesforce");

        // Connect to your data warehouse
        Connection dest = ts.connections()
            .create("snowflake");

        // Create a real-time sync
        Sync sync = ts.sync().create(
            SyncConfig.builder()
                .source(new Endpoint(sf.getId(), "Contact"))
                .destination(new Endpoint(dest.getId(), "contacts"))
                .schedule("realtime")
                .build()
        );

        System.out.printf("Sync created: %s%n", sync.getId());
    }
}

using ThreadSync.Sdk;
using ThreadSync.Sdk.Models;

// Initialize the client
var ts = new ThreadSyncClient(
    bearerToken: Environment.GetEnvironmentVariable("THREADSYNC_API_TOKEN")
);

// Connect to Salesforce
var sf = await ts.Connections.CreateAsync("salesforce");

// Connect to your data warehouse
var dest = await ts.Connections.CreateAsync("snowflake");

// Create a real-time sync
var sync = await ts.Sync.CreateAsync(new SyncConfig
{
    Source = new Endpoint { Connection = sf.Id, Object = "Contact" },
    Destination = new Endpoint { Connection = dest.Id, Table = "contacts" },
    Schedule = "realtime"
});

Console.WriteLine($"Sync created: {sync.Id}");

require 'threadsync'

# Initialize the client
ts = ThreadSync::Client.new(
  bearer_token: ENV['THREADSYNC_API_TOKEN']
)

# Connect to Salesforce
sf = ts.connections.create(provider: 'salesforce')

# Connect to your data warehouse
dest = ts.connections.create(provider: 'snowflake')

# Create a real-time sync
sync = ts.sync.create(
  source: { connection: sf.id, object: 'Contact' },
  destination: { connection: dest.id, table: 'contacts' },
  schedule: 'realtime'
)

# Check sync status
status = ts.sync.get(sync.id)
puts "Synced #{status.records_synced} records"

<?php
use ThreadSync\Client;
use ThreadSync\Models\SyncConfig;

// Initialize the client
$ts = new Client(
    bearerToken: getenv('THREADSYNC_API_TOKEN')
);

// Connect to Salesforce
$sf = $ts->connections->create('salesforce');

// Connect to your data warehouse
$dest = $ts->connections->create('snowflake');

// Create a real-time sync
$sync = $ts->sync->create(new SyncConfig(
    source: ['connection' => $sf->id, 'object' => 'Contact'],
    destination: ['connection' => $dest->id, 'table' => 'contacts'],
    schedule: 'realtime'
));

echo "Sync created: {$sync->id}\n";

use threadsync::{Client, SyncConfig, Endpoint};
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the client
    let ts = Client::new(
        &env::var("THREADSYNC_API_TOKEN")?
    );

    // Connect to Salesforce
    let sf = ts.connections()
        .create("salesforce")
        .await?;

    // Connect to your data warehouse
    let dest = ts.connections()
        .create("snowflake")
        .await?;

    // Create a real-time sync
    let sync = ts.sync().create(SyncConfig {
        source: Endpoint { connection: sf.id.clone(), object: "Contact".into() },
        destination: Endpoint { connection: dest.id.clone(), table: "contacts".into() },
        schedule: "realtime".into(),
    }).await?;

    println!("Sync created: {}", sync.id);
    Ok(())
}