Data Sources

A DataSource represents an external system — a cloud provider account, an HR platform, an identity provider, or any other source of entity data. Registering a data source lets cPod pull records into the EDM on demand or on a schedule, keeping your graph current without manual imports.

DataSource Schema

Field	Type	Required	Description
`id`	`string`	auto	Prefixed ID: `ds-{ulid}`
`name`	`string`	yes	Display name (e.g. “AWS Production Account”)
`type`	`enum`	yes	`aws` \| `gcp` \| `azure` \| `okta` \| `workday` \| `github` \| `jira` \| `custom`
`status`	`enum`	auto	`active` \| `error` \| `disabled`
`config`	`object`	yes	Provider-specific connection config (see below)
`lastSyncAt`	`string`	auto	ISO 8601 UTC timestamp of last successful sync
`lastSyncStatus`	`enum`	auto	`success` \| `partial` \| `failed`
`syncSchedule`	`string`	no	Cron expression for automatic syncs
`tags`	`string[]`	no	Free-form tags
`createdAt`	`string`	auto	ISO 8601 UTC

⚠️

The config object may contain credentials. It is stored encrypted at rest and never returned in API responses — only the field names are echoed back, not values.

List & Get Data Sources

import { CpodClient } from '@cpod/sdk'
const sdk = CpodClient.fromEnv()
 
const result = await sdk.dataSources.list({ type: 'aws', limit: 20 })
for (const ds of result.items) {
  console.log(ds.id, ds.name, ds.status, ds.lastSyncAt)
}
 
const source = await sdk.dataSources.get('ds-abc123')

from cpod import CpodClient
sdk = CpodClient.from_env()
 
result = await sdk.data_sources.list(type="aws", limit=20)
for ds in result.items:
    print(ds.id, ds.name, ds.status)
 
source = await sdk.data_sources.get("ds-abc123")

import "github.com/cpod-ai/cpod-sdk-go/datasources"
 
client := cpod.New(os.Getenv("CPOD_API_KEY"))
 
result, err := client.DataSources.List(ctx, datasources.ListOptions{Type: "aws", Limit: 20})
 
source, err := client.DataSources.Get(ctx, "ds-abc123")

Register a Data Source

// AWS account via IAM role
const awsSource = await sdk.dataSources.create({
  name: 'AWS Production',
  type: 'aws',
  config: {
    accountId: '123456789012',
    roleArn: 'arn:aws:iam::123456789012:role/CpodReadOnly',
    regions: ['us-east-1', 'eu-west-1'],
  },
  syncSchedule: '0 2 * * *',  // daily at 02:00 UTC
})
 
// Okta identity provider
const oktaSource = await sdk.dataSources.create({
  name: 'Okta Production',
  type: 'okta',
  config: {
    domain: 'acme.okta.com',
    apiToken: process.env.OKTA_API_TOKEN,
  },
  syncSchedule: '0 * * * *',  // hourly
})

import os
 
aws_source = await sdk.data_sources.create(
    name="AWS Production",
    type="aws",
    config={
        "account_id": "123456789012",
        "role_arn": "arn:aws:iam::123456789012:role/CpodReadOnly",
        "regions": ["us-east-1", "eu-west-1"],
    },
    sync_schedule="0 2 * * *",
)
 
okta_source = await sdk.data_sources.create(
    name="Okta Production",
    type="okta",
    config={
        "domain": "acme.okta.com",
        "api_token": os.environ["OKTA_API_TOKEN"],
    },
    sync_schedule="0 * * * *",
)

awsSource, err := client.DataSources.Create(ctx, datasources.CreateInput{
    Name: "AWS Production",
    Type: "aws",
    Config: map[string]any{
        "accountId": "123456789012",
        "roleArn":   "arn:aws:iam::123456789012:role/CpodReadOnly",
        "regions":   []string{"us-east-1", "eu-west-1"},
    },
    SyncSchedule: "0 2 * * *",
})

Update & Delete

// Update the sync schedule or config
await sdk.dataSources.update('ds-abc123', {
  syncSchedule: '0 */6 * * *',  // every 6 hours
})
 
// Disable a source without deleting it
await sdk.dataSources.update('ds-abc123', { status: 'disabled' })
 
await sdk.dataSources.delete('ds-abc123')

await sdk.data_sources.update("ds-abc123", sync_schedule="0 */6 * * *")
await sdk.data_sources.update("ds-abc123", status="disabled")
await sdk.data_sources.delete("ds-abc123")

_, err = client.DataSources.Update(ctx, "ds-abc123", datasources.UpdateInput{
    SyncSchedule: "0 */6 * * *",
})
err = client.DataSources.Delete(ctx, "ds-abc123")

Trigger a Manual Sync

// Kick off an immediate sync
const job = await sdk.dataSources.sync('ds-abc123')
// job.id     → "job-01HXYZ..."
// job.status → "queued"
 
// Wait for completion (polls internally)
const result = await sdk.jobs.wait(job.id, { timeoutMs: 120_000 })
// result.output → { created: 34, updated: 12, deleted: 2, errors: 0 }
 
// Get sync history
const history = await sdk.dataSources.syncHistory('ds-abc123', { limit: 10 })
for (const entry of history.items) {
  console.log(entry.startedAt, entry.status, entry.output)
}

job = await sdk.data_sources.sync("ds-abc123")
 
result = await sdk.jobs.wait(job.id, timeout_ms=120_000)
print(result.output)
 
history = await sdk.data_sources.sync_history("ds-abc123", limit=10)
for entry in history.items:
    print(entry.started_at, entry.status)

job, err := client.DataSources.Sync(ctx, "ds-abc123")
 
result, err := client.Jobs.Wait(ctx, job.ID, 120000)
fmt.Println(result.Output)
 
history, err := client.DataSources.SyncHistory(ctx, "ds-abc123", 10, "")
for _, entry := range history.Items {
    fmt.Println(entry.StartedAt, entry.Status)
}

Relationships Overview