# SDK Delivery and Recovery
Generated: 2026-11-03T08:09:41.944Z
Source build: local
Canonical docs: https://teammately.ai/docs
---
id: sdks.delivery
title: SDK Delivery and Recovery
summary: Understand batch identity, retries, memory buffering, shutdown and processing outcomes across SDKs.
kind: reference
product_area: developer_tools
status: stable
updated: 2026-10-31
canonical: /docs/sdks/delivery-and-recovery
---
# SDK Delivery and Recovery
## Definition
Your application chooses what to capture, how to redact it, how long to wait and how to retain source records. The SDK preserves captured data and logical batch identity during submission.
## Fields, states, or lifecycle rules
| Acknowledgement | What it establishes |
| --- | --- |
| Ingestor `add` / `Add` returns | A copied record is in memory |
| Submission returns a receipt | Durable server admission is known |
| Receipt becomes `processed` | Processing finished; inspect all row counts |
| Receipt is `failed`, `cancelled` or `deleted` | Terminal outcome to inspect |
Buffers are memory-only, with no disk outbox or crash-delivery guarantee. Keep original records until admission is known.
## Immutable batches and retries
Prepare a batch once and retain its bytes and application-owned key. Transient `429`, `502`, `503`, `504` and uncertain network failures retry identical bytes/key. `Retry-After` is honored independently of backoff. Permanent failures return directly.
Default retry counts and operation durations are uncapped unless the caller supplies limits or cancellation. Choose explicit application policies. A deadline stops the wait, not durable server work.
Python `Batch.restore`, TypeScript `Batch.restore` and Go `RestoreBatch` retain original bytes for caller-owned recovery. Keep these bytes secure. Re-encoding changed content under the same key can conflict.
## Continuous ingestion and shutdown
Capacities default to uncapped; caller-selected capacities include in-flight rows and can apply backpressure. Automatic dispatch has no imposed delay. Explicit flush and close drain serially.
A failed batch remains pending and pauses automatic flushing. Inspect status/pending batch, correct the failure and retry flush or close. Close stops new input and scheduling, consumes an in-flight result and attempts to drain. A failed or timed-out close can be retried.
Receipt callbacks report admission, not processing. Return promptly. Python callbacks can run on background threads; callbacks must not close their own ingestor. Go callbacks run outside locks.
## Privacy and errors
Select and redact captured content before submission; the SDK does not automatically scrub it. Keep keys on the server. HTTPS is required outside loopback; credentials do not follow redirects. SDKs do not emit telemetry or discover stored login credentials.
Inspect structured API errors and processing receipts. A processed batch can have rejected or conflicting rows; an unknown transport outcome is not a confirmed rejection.
## Related task pages
{% related-card-grid %}
- [Python](/docs/sdks/python)
- [TypeScript](/docs/sdks/typescript)
- [Go](/docs/sdks/go)
- [Fieldloop troubleshooting](/docs/troubleshooting/fieldloop)
{% /related-card-grid %}
---
id: sdks.overview
title: Application SDKs
summary: Choose a server-side SDK and follow a complete Fieldloop submission and receipt example.
kind: reference
product_area: developer_tools
status: stable
updated: 2026-10-31
canonical: /docs/sdks
---
# Application SDKs
## Definition
Use an application SDK inside a backend service, worker or serverless function. Supply its API key through the deployed host's secret mechanism. These libraries do not install the CLI, open browser login, discover credentials or run a local evaluator.
## Choose a language
| Guide | Package identity | Runtime | Resources |
| --- | --- | --- | --- |
| [Python](/docs/sdks/python) | `teammately` | Python 3.10+ | Fieldloop |
| [JavaScript / TypeScript](/docs/sdks/typescript) | `@teammately/sdk` | Node.js 22+, ES modules | Fieldloop |
| [Go](/docs/sdks/go) | `github.com/teammately/teammately-go` | Go 1.25.1+ | Fieldloop and evaluation operations |
Each guide describes installation from a source checkout and a batch call. Resource coverage differs across languages. Use [REST](/docs/public-api) or the [CLI](/docs/cli) for evaluation workflows outside your language client's resource surface.
## Fields, states, or lifecycle rules
A new Fieldloop Submission key authorizes that capability across its workspace. The application supplies organization, Project and source identifiers; current server permissions apply. Older restricted keys retain their restrictions.
`source_event_id` and batch idempotency keys belong to your application. Project/source IDs and receipts are issued by Teammately. In-memory enqueue, durable admission and completed processing are different acknowledgements.
Read [Delivery and Recovery](/docs/sdks/delivery-and-recovery) before continuous ingestion. It covers immutable batches, retries, shutdown, row outcomes and privacy.
## Related task pages
{% related-card-grid %}
- [Python quickstart](/docs/sdks/python)
- [TypeScript quickstart](/docs/sdks/typescript)
- [Go quickstart](/docs/sdks/go)
- [Capture and Inspect Logs](/docs/fieldloop/ingest-logs)
{% /related-card-grid %}
---
id: fieldloop.ingest
title: Capture and Inspect Logs
summary: Configure a source destination, submit captured application records, and distinguish durable admission from processing completion.
kind: task
product_area: fieldloop
status: stable
updated: 2026-10-30
canonical: /docs/fieldloop/ingest-logs
---
# Capture and Inspect Logs
Capture the application facts that explain a behavior question. Keep the original records until their admission is known.
## Prerequisites
- The intended workspace, Project and Fieldloop source.
- Authorization to submit to that destination.
- Actual captured content and stable application event identities.
- Explicit source processing consent where screening is enabled.
## Submit captured records
Use the source's supported submission path with the configured destination. Application-library calls can submit batches and inspect receipts without installing a CLI or signing in through a browser.
Follow the [Python](/docs/sdks/python), [TypeScript](/docs/sdks/typescript) or [Go](/docs/sdks/go) quickstart for a complete batch example, or use the [Fieldloop REST guide](/docs/public-api/fieldloop).
Provide a Fieldloop submission credential through your application's approved secret mechanism. A newly created Fieldloop key grants that capability across its workspace; the sender still identifies the Project and source. Existing more restricted keys keep their restrictions.
Preserve the exact batch content and idempotency key when recovering an uncertain request. A successful admission does not mean every row has completed processing.
## Inspect Logs
Open Logs, choose the intended time range and source, then inspect the original record, relationships and processing state. Captured messages, context, trajectories and feedback remain distinct fields rather than a synthesized replacement for what happened.
Read receipt counts for accepted, duplicate, conflicting and rejected rows. A processed batch can still contain row-level outcomes that need attention.
## Object and state changes
Submission records durable intake and admits processing work. Processing publishes the captured log and its attributable snapshot. Further analysis can create or update Threads separately.
SDK buffering can acknowledge memory before server admission. It is not a disk outbox or a guarantee of crash delivery. Caller-owned cancellation and recovery should preserve the exact source records and batch identity.
## Success criteria
- Records reached the intended Project and source.
- Original content and event identities are preserved.
- Admission and processing outcomes are understood separately.
- Credentials do not appear in logs, reports or copied tasks.
## Common failure modes
- Using a key for another workspace.
- Re-encoding changed content under the same retry identity.
- Treating receipt polling as a new submission.
- Assuming a captured record was analyzed without source consent.
- Treating temporary client buffering as durable admission.
## Related reference pages
{% related-card-grid title="Related reference pages" %}
- [Fieldloop](/docs/fieldloop)
- [Read Fieldloop Threads](/docs/fieldloop/threads)
- [API Keys and Delegated Access](/docs/admin-console/api-keys)
{% /related-card-grid %}
## Related troubleshooting pages
{% related-card-grid title="Related troubleshooting pages" %}
- [Fieldloop Intake and Processing](/docs/troubleshooting/fieldloop)
- [Permissions troubleshooting](/docs/troubleshooting/permissions)
{% /related-card-grid %}
---
id: public-api.fieldloop
title: Fieldloop Batches and Receipts
summary: Submit captured logs, preserve retry identity and inspect admission and row processing separately.
kind: api
product_area: public_api
status: stable
updated: 2026-10-31
canonical: /docs/public-api/fieldloop
---
# Fieldloop Batches and Receipts
## Definition
Submit captured application records to an existing source with a Fieldloop Submission key from **Admin → API Keys**. New keys carry that capability across the workspace. Configure the intended Project/source; older key restrictions and current permissions remain enforced. Receipt reads belong to the original submitter.
## Submit a batch
```http
POST /v1/organizations/{organizationKey}/projects/{projectId}/fieldloop/sources/{sourceId}/batches
Authorization: Bearer
Content-Type: application/json
Idempotency-Key:
```
### Example: Captured log body
```json
{
"logs": [{
"source_event_id": "support-ticket-1042:reply",
"occurred_at": "2026-10-31T09:30:00Z",
"input": {"question": "Has my bicycle shipped?"},
"output": {"reply": "Your bicycle is being packed."},
"context": {"application": "Bicycle Shop"}
}]
}
```
Replace the fictional record with selected, redacted data in `batch.json`. Your application owns `source_event_id`. Each log needs RFC3339 `occurred_at` and at least one of `input`, `output`, `messages`, `trajectory` or `action`. Optional feedback is nested in its log; source relationships use `provider_ref`, `session_ref` and `trace_ref`.
### Example: Submit a batch
```sh
SOURCE_URL="${PROJECT_URL}/fieldloop/sources/${TEAMMATELY_FIELDLOOP_SOURCE}"
curl --fail-with-body \
--header "Authorization: Bearer ${TEAMMATELY_API_KEY}" \
--header 'Content-Type: application/json' \
--header "Idempotency-Key: ${BATCH_OPERATION_KEY}" \
--data-binary @batch.json \
"${SOURCE_URL}/batches"
```
```python
import os
from pathlib import Path
from urllib.parse import quote
from urllib.request import HTTPRedirectHandler, Request, build_opener
class NoRedirect(HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
return None
opener = build_opener(NoRedirect())
api_key = os.environ["TEAMMATELY_API_KEY"]
url = os.environ["PROJECT_URL"] + "/fieldloop/sources/" + quote(os.environ["TEAMMATELY_FIELDLOOP_SOURCE"], safe="") + "/batches"
headers = {"Authorization": "Bearer " + api_key}
headers["Idempotency-Key"] = os.environ["BATCH_OPERATION_KEY"]
headers["Content-Type"] = "application/json"
body = Path("batch.json").read_bytes()
request = Request(url, data=body, headers=headers, method="POST")
with opener.open(request) as response:
print(response.read().decode("utf-8"))
```
```typescript
import { readFile } from "node:fs/promises";
const apiKey = process.env.TEAMMATELY_API_KEY!;
{
const url = new URL(process.env.PROJECT_URL! + "/fieldloop/sources/" + encodeURIComponent(process.env.TEAMMATELY_FIELDLOOP_SOURCE!) + "/batches");
const response = await fetch(url, {
method: "POST",
redirect: "error",
headers: {
Authorization: `Bearer ${apiKey}`,
"Idempotency-Key": process.env.BATCH_OPERATION_KEY!,
"Content-Type": "application/json",
},
body: new Uint8Array(await readFile("batch.json")).buffer,
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.text());
}
```
```go
package main
import (
"bytes"
"context"
"fmt"
"io"
"log"
"net/http"
"net/url"
"os"
)
func main() {
if err := run(context.Background()); err != nil { log.Fatal(err) }
}
func run(ctx context.Context) error {
client := &http.Client{
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
{
target := os.Getenv("PROJECT_URL") + "/fieldloop/sources/" + url.PathEscape(os.Getenv("TEAMMATELY_FIELDLOOP_SOURCE")) + "/batches"
payload, err := os.ReadFile("batch.json")
if err != nil { return err }
request, err := http.NewRequestWithContext(ctx, "POST", target, bytes.NewReader(payload))
if err != nil { return err }
request.Header.Set("Authorization", "Bearer " + os.Getenv("TEAMMATELY_API_KEY"))
request.Header.Set("Idempotency-Key", os.Getenv("BATCH_OPERATION_KEY"))
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil { return err }
payloadBytes, readErr := io.ReadAll(response.Body)
response.Body.Close()
if readErr != nil { return readErr }
fmt.Println(string(payloadBytes))
if response.StatusCode < 200 || response.StatusCode >= 300 { return fmt.Errorf("HTTP %d", response.StatusCode) }
}
return nil
}
```
Use the Project URL from the [quickstart](/docs/public-api/quickstart), an existing issued source ID and one logical batch key. Preserve the exact file/key for uncertain retries.
## Read the receipt
`202` acknowledges durable receipt of the bytes. Retain `data.batch_id`:
### Example: Read a receipt
```sh
curl --fail-with-body \
--header "Authorization: Bearer ${TEAMMATELY_API_KEY}" \
"${SOURCE_URL}/batches/${BATCH_ID}"
```
```python
import os
from urllib.parse import quote
from urllib.request import HTTPRedirectHandler, Request, build_opener
class NoRedirect(HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
return None
opener = build_opener(NoRedirect())
api_key = os.environ["TEAMMATELY_API_KEY"]
url = os.environ["PROJECT_URL"] + "/fieldloop/sources/" + quote(os.environ["TEAMMATELY_FIELDLOOP_SOURCE"], safe="") + "/batches/" + quote(os.environ["BATCH_ID"], safe="")
headers = {"Authorization": "Bearer " + api_key}
request = Request(url, headers=headers, method="GET")
with opener.open(request) as response:
print(response.read().decode("utf-8"))
```
```typescript
const apiKey = process.env.TEAMMATELY_API_KEY!;
{
const url = new URL(process.env.PROJECT_URL! + "/fieldloop/sources/" + encodeURIComponent(process.env.TEAMMATELY_FIELDLOOP_SOURCE!) + "/batches/" + encodeURIComponent(process.env.BATCH_ID!));
const response = await fetch(url, {
method: "GET",
redirect: "error",
headers: {
Authorization: `Bearer ${apiKey}`,
},
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
console.log(await response.text());
}
```
```go
package main
import (
"context"
"fmt"
"io"
"log"
"net/http"
"net/url"
"os"
)
func main() {
if err := run(context.Background()); err != nil { log.Fatal(err) }
}
func run(ctx context.Context) error {
client := &http.Client{
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
{
target := os.Getenv("PROJECT_URL") + "/fieldloop/sources/" + url.PathEscape(os.Getenv("TEAMMATELY_FIELDLOOP_SOURCE")) + "/batches/" + url.PathEscape(os.Getenv("BATCH_ID"))
request, err := http.NewRequestWithContext(ctx, "GET", target, nil)
if err != nil { return err }
request.Header.Set("Authorization", "Bearer " + os.Getenv("TEAMMATELY_API_KEY"))
response, err := client.Do(request)
if err != nil { return err }
payloadBytes, readErr := io.ReadAll(response.Body)
response.Body.Close()
if readErr != nil { return readErr }
fmt.Println(string(payloadBytes))
if response.StatusCode < 200 || response.StatusCode >= 300 { return fmt.Errorf("HTTP %d", response.StatusCode) }
}
return nil
}
```
| Field | Interpretation |
| --- | --- |
| `batch_id`, `source_id`, `sequence` | Issued identity and destination order |
| `status` | `uploading`, `received`, `processing`, `processed`, `failed`, `cancelled` or `deleted` |
| `row_count` | Submitted population |
| `accepted_count`, `duplicate_count` | Accepted records and recognized duplicates |
| `conflict_count`, `rejected_count` | Rows requiring inspection |
| `rows`, `safe_error_code` | Per-row outcomes and error code when returned |
`processed` can include rejected/conflicting rows. Polling reads an existing batch rather than submitting another one.
## Recovery and inspection
Replay a lost response with identical bytes/key. Retain source records until admission is known. Inspect **Fieldloop → Logs** for original content and processing state. Source consent, Threads and Case creation are separate workflows.
[SDK guides](/docs/sdks) cover continuous ingestion. `FieldloopBatch`, `FieldloopLog` and `FieldloopReceiptEnvelope` in the [OpenAPI](https://api.teammately.ai/v1/openapi.yaml) define request/receipt fields.
## Related reference pages
{% related-card-grid %}
- [API keys](/docs/admin-console/api-keys)
- [Fieldloop troubleshooting](/docs/troubleshooting/fieldloop)
{% /related-card-grid %}