Integrate in your
language of choice.

import { IntegrationPlatform, fromEnv } from '@integration-platform/sdk';

// Explicit config
const client = new IntegrationPlatform({
  apiKey: 'ip_live_...',
  tenantId: 'acme-corp',
  baseUrl: 'https://api.integration-platform.io',
  timeout: 30_000,
  maxRetries: 3,
});

// From env: IP_API_KEY, IP_TENANT_ID, IP_BASE_URL
const client2 = fromEnv();

// Health check
const { status } = await client.health();
console.log(status); // 'UP'

import { IntegrationPlatform, ConnectorType } from '@integration-platform/sdk';

const sftp = await client.connectors.create({
  name: 'SFTP Production',
  type: 'SFTP',
  config: { host: 'sftp.empresa.pt', port: 22, remotePath: '/outbound' },
  credentials: { username: 'integrations', password: '***' },
});
console.log(sftp.id, sftp.status);

// Test connectivity
const tested = await client.connectors.test(sftp.id);
console.log(`Status: ${tested.status} — ${tested.lastTestResult}`);

// Iterate all connectors (async generator)
for await (const conn of client.connectors.iterAll()) {
  console.log(`${conn.name} [${conn.type}] ${conn.status}`);
}

// Create and test integration
const flow = await client.integrations.create({
  name: 'SFTP → Salesforce Sync',
  sourceConnectorId: sftp.id,
  targetConnectorId: 'salesforce-prod-id',
  errorStrategy: 'RETRY_3_DLQ',
  tags: ['sftp', 'salesforce'],
});

// Sandbox test
const result = await client.sandbox.execute({
  integrationId: flow.id,
  payload: { nome_completo: 'Test User', email: 'test@ex.pt' },
});

if (result.success) {
  // Promote to QA then PROD
  await client.integrations.promote(flow.id, 'QA');
  await client.integrations.promote(flow.id, 'PROD', 'All tests passed');
  console.log('Deployed to PROD!');
}

// Express webhook handler with signature verification
import express from 'express';
import { verifyWebhookSignature } from '@integration-platform/sdk';

const app = express();
app.use(express.raw({ type: 'application/json' }));

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-ip-signature'] as string;

  const isValid = verifyWebhookSignature({
    payload: req.body,
    signature,
    secret: process.env.IP_WEBHOOK_SECRET!,
  });

  if (!isValid) return res.sendStatus(401);

  const event = JSON.parse(req.body);
  console.log(`Event: ${event.type}`); // dlq.entry.created, integration.failed

  res.sendStatus(200);
});

import com.integrationplatform.sdk.IntegrationPlatformClient;

// Builder initialisation
IntegrationPlatformClient client = IntegrationPlatformClient
    .builder()
    .apiKey("ip_live_...")
    .tenantId("acme-corp")
    .baseUrl("https://api.integration-platform.io")
    .timeout(Duration.ofSeconds(30))
    .build();

// From environment variables: IP_API_KEY, IP_TENANT_ID
IntegrationPlatformClient client2 = IntegrationPlatformClient.fromEnv();

// Health check
Map<String, Object> health = client.health();
System.out.println(health.get("status")); // UP

// Create connector with builder
ConnectorDefinition sftp = client.connectors().create(
    CreateConnectorRequest.builder()
        .name("SFTP Production")
        .type(ConnectorType.SFTP)
        .config(Map.of(
            "host", "sftp.empresa.pt",
            "port", 22,
            "remotePath", "/outbound"
        ))
        .credentials(Map.of(
            "username", "integrations",
            "password", "***"
        ))
        .build()
);
System.out.println("Created: " + sftp.id());

// Test and sandbox
ConnectorDefinition tested = client.connectors().test(sftp.id());
System.out.println("Status: " + tested.status());

SandboxResult result = client.sandbox().execute(
    flow.id(),
    Map.of("email", "test@ex.pt", "ativo", true)
);
System.out.println(result.success() ? "PASS" : "FAIL");

# application.yml
integration-platform:
  api-key: ${IP_API_KEY}
  tenant-id: ${IP_TENANT_ID}
  base-url: https://api.integration-platform.io
  timeout: 30s

// Auto-configured bean — just inject it:
@Service
@RequiredArgsConstructor
public class MyIntegrationService {

    private final IntegrationPlatformClient ipClient;

    public void syncContacts() {
        SandboxResult result = ipClient.sandbox().execute(
            "integration-uuid",
            Map.of("email", "user@example.pt")
        );
        if (!result.success()) {
            log.warn("Sync failed: {}", result.validationErrors());
        }
    }
}