Getting SDK Connection Details

import DittoSwift
import Foundation // v5 no longer re-exports Foundation; needed for URL

// Create a DittoConfig with your database ID.
// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
let config = DittoConfig(
    databaseID: "REPLACE_ME_WITH_YOUR_DATABASE_ID",
    connect: .server(url: URL(string: "REPLACE_ME_WITH_YOUR_URL")!)
)

// Open Ditto with the configuration
let ditto = try await Ditto.open(config: config)

// Set up authentication expiration handler
ditto.auth?.expirationHandler = { ditto, secondsRemaining in
    ditto.auth?.login(token: "YOUR_PLAYGROUND_TOKEN", provider: .development) { clientInfo, error in
        if let error = error {
            print("Authentication error: \(error)")
        } else {
            print("Authentication successful")
        }
    }
}

// Start syncing
do {
    try ditto.sync.start()
} catch {
    print("Error starting sync: \(error.localizedDescription)")
}

val config = DittoConfig(
    databaseId = "REPLACE_ME_WITH_YOUR_DATABASE_ID",
    connect = DittoConfig.Connect.Server(url = "REPLACE_ME_WITH_YOUR_URL")
)
val ditto = DittoFactory.create(config)

// Auth is null when using Connect.SmallPeersOnly — guard with `?.let { }`.
ditto.auth?.let { auth ->
    auth.expirationHandler = { ditto, timeUntilExpiration ->
        // This lambda is suspend — call login() directly, no separate coroutine.
        ditto.auth?.login(
            token = "YOUR_PLAYGROUND_TOKEN",
            provider = DittoAuthenticationProvider.development(),
        )
    }
}

ditto.sync.start()

import 'package:ditto_live/ditto_live.dart';

await Ditto.init();

// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
final config = DittoConfig(
  databaseID: 'REPLACE_ME_WITH_YOUR_DATABASE_ID',
  connect: DittoConfigConnectServer(
    url: 'REPLACE_ME_WITH_YOUR_URL',
  ),
);

final ditto = await Ditto.open(config);

await ditto.auth.setExpirationHandler((ditto, timeUntilExpiration) async {
  final result = await ditto.auth.login(
    token: 'REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN',
    provider: Authenticator.developmentProvider,
  );
  if (result.exception != null) {
    print('Auth error: ${result.exception}');
  }
});

ditto.sync.start();

import { init, Ditto, DittoConfig, Authenticator } from '@dittolive/ditto'

await init()

const databaseID = 'REPLACE_ME_WITH_YOUR_DATABASE_ID'
// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
const config = new DittoConfig(databaseID, {
  mode: 'server',
  url: 'REPLACE_ME_WITH_YOUR_URL'
})

const ditto = await Ditto.open(config)

await ditto.auth.setExpirationHandler(async (ditto, secondsRemaining) => {
  console.log('Token expiring in:', secondsRemaining)
  const result = await ditto.auth.login('REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN', Authenticator.DEVELOPMENT_PROVIDER)
  if (result.error) {
    console.error('Auth error:', result.error)
  }
})

ditto.sync.start()

import { init, Ditto, DittoConfig, Authenticator } from '@dittolive/ditto'

await init()

const databaseID: string = 'REPLACE_ME_WITH_YOUR_DATABASE_ID'
// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
const config = new DittoConfig(databaseID, {
  mode: 'server',
  url: 'REPLACE_ME_WITH_YOUR_URL'
})

const ditto: Ditto = await Ditto.open(config)

await ditto.auth.setExpirationHandler(async (ditto: Ditto, secondsRemaining: number) => {
  console.log('Token expiring in:', secondsRemaining)
  const result = await ditto.auth.login('REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN', Authenticator.DEVELOPMENT_PROVIDER)
  if (result.error) {
    console.error('Auth error:', result.error)
  }
})

ditto.sync.start()

import com.ditto.java.Ditto;
import com.ditto.java.DittoAuthenticationProvider;
import com.ditto.java.DittoConfig;
import com.ditto.java.DittoException;
import com.ditto.java.DittoFactory;

// Your HTTP Cloud URL Endpoint
String endpoint = "REPLACE_ME_WITH_YOUR_URL";
String databaseId = "REPLACE_ME_WITH_YOUR_DATABASE_ID";

DittoConfig config = new DittoConfig.Builder(databaseId)
    .connect(new DittoConfig.Connect.Server(endpoint))
    .build();

try {
    Ditto ditto = DittoFactory.create(config);

    // Set up authentication expiration handler (required for server connections).
    // The handler returns a CompletionStage<Void>.
    ditto.getAuth().setExpirationHandler((expiringDitto, timeUntilExpiration) ->
        expiringDitto.getAuth().login(
            "REPLACE_ME_WITH_YOUR_DEVELOPMENT_TOKEN",
            DittoAuthenticationProvider.development()
        ).thenAccept(result -> {
            if (result.error() != null) {
                System.out.println("Authentication failed: " + result.error());
            } else {
                System.out.println("Authentication successful");
            }
        })
    );

    // Start sync (v5 pattern: ditto.getSync().start())
    ditto.getSync().start();
} catch (DittoException e) {
    System.out.println("Ditto initialization failed: " + e.getMessage());
}

using DittoSDK;

// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
var databaseId = "REPLACE_ME_WITH_YOUR_DATABASE_ID";
var config = new DittoConfig(
    databaseId: databaseId,
    connect: new DittoConfigConnect.Server(new Uri("REPLACE_ME_WITH_YOUR_URL"))
);

var ditto = await Ditto.OpenAsync(config);

ditto.Auth.ExpirationHandler = async (ditto, secondsRemaining) => {
    try
    {
        var result = await ditto.Auth.LoginAsync("YOUR_PLAYGROUND_TOKEN", DittoAuthenticationProvider.Development);
    }
    catch (Exception e)
    {
        Console.WriteLine($"Authentication failed: {e}");
    }
};

ditto.Sync.Start();

#include <ditto/ditto.h>

// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
auto database_id = "REPLACE_ME_WITH_YOUR_DATABASE_ID";
auto config = ditto::DittoConfig(
    database_id,
    ditto::DittoConnect::server("REPLACE_ME_WITH_YOUR_URL")
);

auto ditto = ditto::Ditto::open(config);

ditto->auth()->set_expiration_handler([](ditto::Ditto& ditto, int64_t seconds_remaining) {
    ditto.auth()->login("YOUR_PLAYGROUND_TOKEN", ditto::Authenticator::development_provider(),
        [](const ditto::AuthenticationSuccess* success, const ditto::DittoError* error) {
            if (error) {
                std::cerr << "Auth error" << std::endl;
            }
        });
});

ditto->update_transport_config([&](ditto::TransportConfig &config) {
    config.enable_all_peer_to_peer();
});

ditto->get_sync()->start();

use dittolive_ditto::prelude::*;
use std::time::Duration;

// Initialize with DittoConfig using database_id (was app_id in v4).
// Copy the "URL" and "Database ID" from the Ditto Portal (Connect via SDK).
let database_id = DatabaseId::from_str("REPLACE_ME_WITH_YOUR_DATABASE_ID")?;
let config = DittoConfig::new(
    database_id.clone(),
    DittoConnect::Server {
        url: "REPLACE_ME_WITH_YOUR_URL".to_string()
    }
);

let ditto = Ditto::open(config)?;

// Set up authentication expiration handler
ditto.auth().set_expiration_handler(|ditto, seconds_remaining| {
    ditto.auth().login(
        "REPLACE_ME_WITH_YOUR_PLAYGROUND_TOKEN",
        Authenticator::development_provider(),
        |result| {
            if let Err(e) = result {
                eprintln!("Auth error: {}", e);
            }
        }
    );
});

// Configure transport (optional)
ditto.set_transport_config({
    let mut config = TransportConfig::new();
    config
        .connect
        .websocket_urls
        // Your Portal URL with the scheme changed from https:// to wss:// (host only)
        .insert("wss://REPLACE_ME_WITH_YOUR_URL_HOST".to_string());
    config
});

// Start sync (was ditto.start_sync() in v4)
ditto.sync().start()?;

const endpoint = "REPLACE_ME_WITH_YOUR_URL"
const id       = "REPLACE_ME_WITH_YOUR_DATABASE_ID"
const token    = "REPLACE_ME_WITH_YOUR_DEVELOPMENT_TOKEN"

config := ditto.DefaultDittoConfig().
    WithDatabaseID(id).
    WithConnect(&ditto.DittoConfigConnectServer{URL: endpoint})

dit, err := ditto.Open(config)
if err != nil {
    log.Fatalf("error: failed to open Ditto: %v", err)
}
defer dit.Close()

// Set up authentication expiration handler (required for server connections)
dit.Auth().SetExpirationHandler(
    func(d *ditto.Ditto, timeUntilExpiration time.Duration) {
        _, err := d.Auth().Login(token, ditto.DevelopmentAuthenticationProvider())
        if err != nil {
            log.Errorf("Authentication failed: %v", err)
        } else {
            log.Printf("Authentication succeeded")
        }
    })

if err := dit.Sync().Start(); err != nil {
    log.Errorf("error: failed to start sync: %v", err)
}