Kotlin SDK

// build.gradle.kts
implementation("com.fopost:fopost-kotlin:0.1.0")

<dependency>
  <groupId>com.fopost</groupId>
  <artifactId>fopost-kotlin</artifactId>
  <version>0.1.0</version>
</dependency>

import com.fopost.FoPost
import com.fopost.param.CreatePostParams
import com.fopost.param.contentOf

FoPost("fp_...").use { client ->          // or set FOPOST_API_KEY
    val workspace = client.workspaces.list().first()
    val accounts = client.accounts.list(workspace.id)

    val post = client.posts.create(
        CreatePostParams(
            workspaceId = workspace.id!!,
            accounts = accounts.mapNotNull { it.id },
            content = contentOf("Hello from Kotlin"),
        ),
    )

    client.posts.publish(post.id!!)
}

client.posts.create(
    CreatePostParams(
        workspaceId = workspaceId,
        accounts = listOf(accountId),
        content = listOf(
            ContentBlockInput("First post in the thread"),
            ContentBlockInput(
                "Second one, with an image",
                media = listOf(MediaItem(type = "image", name = "chart.png", url = "https://.../chart.png")),
            ),
        ),
    ),
)

val file = client.media.upload(workspaceId, File("chart.png")).first()

client.posts.create(
    CreatePostParams(
        workspaceId = workspaceId,
        accounts = listOf(accountId),
        content = listOf(ContentBlockInput("Numbers are in", media = listOf(file.toMediaItem()))),
    ),
)

val posts = coroutineScope {
    val drafts = async { client.posts.list(PostListParams(status = PostStatus.DRAFT)) }
    val scheduled = async { client.posts.list(PostListParams(status = PostStatus.SCHEDULED)) }
    drafts.await().data + scheduled.await().data
}

// AndroidManifest.xml
<uses-permission android:name="android.permission.INTERNET" />

// build.gradle.kts
android {
    defaultConfig { minSdk = 26 }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
}

client.posts.create(
    CreatePostParams(
        workspaceId = workspaceId,
        accounts = listOf(accountId),
        content = contentOf("Scheduled with the SDK"),
    ).scheduledAt(Instant.parse("2026-09-01T10:00:00Z")),
)

val check = client.posts.preflight(post.id!!)
if (check.ready != true) {
    check.accounts.forEach { println("${it.platform}: ${it.issues}") }
}

val page = client.posts.list(PostListParams(workspaceId = workspaceId, perPage = 50))
println("${page.meta?.total} posts")

client.posts.listAll(PostListParams(workspaceId = workspaceId))
    .filter { it.status == PostStatus.FAILED }
    .collect { println(it.id) }

val raw = client.request("GET", "/analytics/overview", query = mapOf("days" to 30))
val platforms: List<String> = client.requestAs("GET", "/platforms")

val hook = client.webhooks.create(
    workspaceId,
    "https://example.com/hooks/fopost",
    listOf(WebhookEvents.POST_PUBLISHED, WebhookEvents.DELIVERY_FAILED),
)

println(hook.secret)
client.webhooks.test(hook.id!!)

val client = FoPost(
    apiKey = "fp_...",                       // or FOPOST_API_KEY
    baseUrl = "https://api.fopost.com/v1",   // or FOPOST_BASE_URL
    maxRetries = 3,                          // total attempts, so 3 means two retries
    timeout = 30.seconds,
    httpClient = myOkHttpClient,             // optional: your own transport
    userAgent = "acme/2.0",                  // optional: prefixed to the SDK's own
)

try {
    client.posts.publish(postId)
} catch (e: PaymentRequiredException) {
    println("Out of credits, upgrade at ${e.upgradeUrl}")
} catch (e: RateLimitException) {
    println("Rate limited, retry in ${e.retryAfter}")
} catch (e: FoPostException) {
    println("API ${e.status} (${e.code}): ${e.message}")
}