List connections (source-to-destination pipelines) in Airbyte.

A connection is the core Airbyte concept: it links a source to a destination, defines which streams to sync, the sync schedule (cron or basic), namespace mapping, and the sync mode per stream. Think of it as a "pipeline definition."

When to Use: - Discover which pipelines exist and their current status (active, inactive, deprecated). - Find a connection's UUID so you can inspect its details or list its jobs. - Audit all pipelines in one or more workspaces.

When NOT to Use: - If you already have a connection ID, use airbyte_get_connection for full details including stream configuration. - To check if a pipeline is currently running or recently failed, use airbyte_list_jobs with the connection_id filter.

Returns: Paginated list of connections. Each entry includes: - name, connectionId (UUID), status, sourceId, destinationId, schedule (cron expression or basic timing), configured streams (first 10 names), namespaceDefinition.

Markdown format shows a heading per connection with bullet
fields. JSON format returns the raw API response array.

Pagination: Use limit (1–100, default 20) and offset (default 0).

Examples: List all connections in a workspace: params = { "workspace_ids": ["a1b2c3d4-..."] } List first 10 connections: params = { "limit": 10 } Include soft-deleted connections: params = { "include_deleted": true } Get raw JSON for scripting: params = { "response_format": "json" }

Get full details of a single connection by its UUID.

Returns the complete connection definition: source and destination IDs, sync schedule, namespace mapping, and the full list of configured streams with their sync modes. This is the most detailed view of a pipeline.

When to Use: - Inspect which streams a connection syncs and their modes (full_refresh, incremental, etc.). - Check the schedule (cron expression or basic interval). - Verify source/destination pairing for a known connection. - Debug a pipeline by examining its full configuration.

When NOT to Use: - If you need to browse connections, use airbyte_list_connections. - To see run history (success/failure, bytes synced), use airbyte_list_jobs with connection_id or airbyte_get_job.

Returns: Connection details including: name, connectionId, status, sourceId, destinationId, schedule, namespaceDefinition, and configurations.streams (name + sync mode for each stream).

Markdown format renders a heading with bullet-point fields.
JSON format returns the full API response object.

Examples: Get connection by ID: params = { "connection_id": "a1b2c3d4-..." } Get raw JSON: params = { "connection_id": "a1b2c3d4-...", "response_format": "json" }

Error Handling: Returns a 404 message if the connection ID does not exist.

Create a new connection (source-to-destination pipeline).

A connection links a source to a destination and defines which streams to sync, the schedule, namespace mapping, and sync modes.

When to Use: - Wire up a new data pipeline between an existing source and destination. - Automate pipeline provisioning.

Recommended Workflow: 1. Ensure the source and destination already exist (or create them with airbyte_create_source / airbyte_create_destination). 2. Call airbyte_get_stream_properties with the sourceId (and optionally destinationId) to discover available streams and their supported sync modes. 3. Build the configurations.streams array and call this tool.

Returns: The created connection details including connectionId.

Examples: Minimal connection: params = { "source_id": "...", "destination_id": "...", "name": "Prod Postgres -> BigQuery" } With schedule and streams: params = { "source_id": "...", "destination_id": "...", "name": "Hourly Sync", "schedule": { "scheduleType": "cron", "cronExpression": "0 * * * *" }, "configurations": { "streams": [ { "name": "users", "syncMode": "incremental_append" }, { "name": "orders", "syncMode": "full_refresh_overwrite" } ] }, "status": "active" }

Update an existing connection's configuration.

Uses PATCH semantics: only the fields you provide are changed.

When to Use: - Change a connection's schedule (e.g. from daily to hourly). - Enable/disable a connection by changing its status. - Add or remove streams from the sync. - Update namespace or prefix settings.

Recommended Workflow: 1. Call airbyte_get_connection to see the current configuration. 2. Build the update payload with only the fields to change. 3. Call this tool.

Returns: The updated connection details.

Examples: Pause a connection: params = { "connection_id": "...", "status": "inactive" } Change schedule: params = { "connection_id": "...", "schedule": { "scheduleType": "basic", "basicTiming": "Every 6 hours" } }

List available source connector definitions in a workspace.

Source definitions describe which connector types are available (e.g. Postgres, Stripe, Google Sheets). Each definition has a UUID that can be used when creating a new source.

When to Use: - Find the definition ID for a specific connector type before creating a source with airbyte_create_source. - Audit which custom connectors are installed in a workspace.

Returns: List of source definitions with name, definition ID, and Docker image information.

Examples: params = { "workspace_id": "a1b2c3d4-..." }

Get details of a specific source connector definition.

Returns the full definition including name, Docker image, and connector specification.

When to Use: - Inspect what a specific source connector provides. - Check the Docker image version for a connector.

Examples: params = { "workspace_id": "...", "definition_id": "..." }

List available destination connector definitions in a workspace.

Destination definitions describe which connector types are available (e.g. BigQuery, Snowflake, S3). Each definition has a UUID that can be used when creating a new destination.

When to Use: - Find the definition ID for a specific connector type before creating a destination with airbyte_create_destination. - Audit which custom connectors are installed in a workspace.

Returns: List of destination definitions with name, definition ID, and Docker image information.

Examples: params = { "workspace_id": "a1b2c3d4-..." }

Get details of a specific destination connector definition.

Returns the full definition including name, Docker image, and connector specification.

When to Use: - Inspect what a specific destination connector provides. - Check the Docker image version for a connector.

Examples: params = { "workspace_id": "...", "definition_id": "..." }

List destination connectors configured in Airbyte.

Destinations represent the data targets (warehouses, databases, lakes, SaaS tools, etc.) that Airbyte writes to. Each destination is linked to a workspace and can receive data from one or more sources via connections.

When to Use: - Discover which destination connectors are set up. - Find a destination's UUID to inspect its configuration or look up related connections. - Audit destinations across one or more workspaces.

When NOT to Use: - If you already have a destination ID, use airbyte_get_destination for full details. - To see what data flows into a destination, look at connections (airbyte_list_connections) or jobs (airbyte_list_jobs).

Returns: Paginated list of destinations. Each entry includes: - name, destinationId (UUID), destinationType, workspaceId, createdAt.

Markdown format shows a heading per destination with bullet
fields. JSON format returns the raw API response array.

Pagination: Use limit (1–100, default 20) and offset (default 0).

Examples: List all destinations in a workspace: params = { "workspace_ids": ["a1b2c3d4-..."] } List first 5 destinations across all workspaces: params = { "limit": 5 } Include soft-deleted destinations: params = { "include_deleted": true }

Get full details of a single destination connector by its UUID.

Returns the destination name, type (e.g. bigquery, snowflake, s3), workspace, creation date, and connector configuration. Secrets in the configuration object are masked by the Airbyte API.

When to Use: - Inspect a specific destination's configuration or connector type. - Verify a destination ID is valid. - Check when a destination was created or which workspace owns it.

When NOT to Use: - If you need to browse destinations, use airbyte_list_destinations. - To see sync activity targeting this destination, use airbyte_list_jobs filtered by the relevant connection.

Returns: Destination details including: name, destinationId, destinationType, workspaceId, createdAt, and configuration (secrets masked).

Markdown format renders a heading with bullet-point fields.
JSON format returns the full API response object.

Examples: Get destination by ID: params = { "destination_id": "a1b2c3d4-..." } Get raw JSON: params = { "destination_id": "a1b2c3d4-...", "response_format": "json" }

Error Handling: Returns a 404 message if the destination ID does not exist.

Create a new destination connector in Airbyte.

A destination defines where Airbyte writes data to (a warehouse, database, data lake, SaaS tool, etc.). Each destination type requires its own configuration schema.

When to Use: - Set up a brand-new data destination inside a workspace. - Automate provisioning of destinations for pipeline setup.

Recommended Workflow: 1. Call airbyte_list_destination_definitions to find the definition ID for the connector type you want. 2. Review an existing destination of the same type with airbyte_get_destination to understand the config structure. 3. Call this tool with the appropriate configuration.

Returns: The created destination details.

Examples: params = { "name": "Analytics Warehouse", "workspace_id": "a1b2c3d4-...", "definition_id": "22f6c74f-...", "configuration": { "destinationType": "bigquery", "project_id": "my-project", "dataset_id": "raw_data", "credentials_json": "..." } }

Update an existing destination connector's name or configuration.

Uses PATCH semantics: only the fields you provide are changed.

When to Use: - Change connection credentials (e.g. rotate a service account). - Rename a destination for clarity. - Update connector settings (e.g. change dataset or bucket).

Recommended Workflow: 1. Call airbyte_get_destination to see the current configuration. 2. Build the updated configuration with only the changed fields. 3. Call this tool.

Returns: The updated destination details.

Examples: Rename a destination: params = { "destination_id": "a1b2c3d4-...", "name": "New Name" } Update configuration: params = { "destination_id": "a1b2c3d4-...", "configuration": { "dataset_id": "new_dataset" } }

Check whether the Airbyte API is reachable and healthy.

Sends a lightweight GET /health request to verify connectivity and authentication. Use this as the first call to confirm the Airbyte instance is running before making other requests.

When to Use: - Verify the Airbyte instance is up and reachable. - Diagnose "connection refused" or authentication errors. - Confirm credentials are valid after initial setup.

Returns: "OK – Airbyte API is healthy." on success. On failure, returns a human-readable error with the root cause (e.g. connection refused, 401 unauthorized, timeout).

Examples: Call with no parameters: airbyte_health_check()

Related Tools: After confirming health, use airbyte_list_workspaces to discover available workspaces.

Get detailed job information including per-attempt stats and failure reasons.

Uses the internal Configuration API (POST /v1/jobs/get) which returns much richer data than the public API: full attempt history, per-stream statistics, and structured failure summaries.

When to Use: - A job failed and you need to understand WHY (failure origin, type, message, stacktrace). - You want per-stream record/byte counts for a specific sync. - You need to see how many attempts a job took and what happened in each one.

When NOT to Use: - For a quick status check, use airbyte_get_job (public API). - For actual log lines, use airbyte_get_job_logs or airbyte_get_attempt_logs. - On Airbyte Cloud (internal API not available).

Returns: Job metadata plus a section per attempt with: status, timing, bytes/records synced, per-stream stats, and failure details.

Examples: params = { "job_id": 12345 }

Get the actual log output for a job's sync attempts.

Uses the internal Configuration API (POST /v1/jobs/get_debug_info) to fetch structured log entries for each attempt. Logs can be very large, so use tail_lines to limit output and attempt_number to focus on a specific attempt.

Always returns JSON — structured logs are best consumed as-is by LLMs and scripts. Each log entry contains timestamp, message, level, logSource, and caller metadata.

When to Use: - You need the raw log output to debug a sync failure. - You want to search for specific error messages or stack traces in the logs. - airbyte_get_job_details showed a failure but you need more context from the full logs.

When NOT to Use: - For structured failure info, use airbyte_get_job_details. - On Airbyte Cloud (internal API not available).

Returns: JSON with structured log entries per attempt, truncated to the last tail_lines entries.

Examples: Last 200 entries for all attempts: params = { "job_id": 12345 } Last 500 entries for attempt 0 only: params = { "job_id": 12345, "attempt_number": 0, "tail_lines": 500 }

Get logs for a specific attempt of a job.

Uses the internal Configuration API (POST /v1/attempt/get_for_job) to fetch structured log entries for exactly one attempt. More efficient than airbyte_get_job_logs when you know which attempt failed.

Always returns JSON — structured logs are best consumed as-is.

When to Use: - A job had multiple attempts and you want logs for a specific one (e.g. the failing attempt). - You already identified the failing attempt number from airbyte_get_job_details.

When NOT to Use: - If you want logs for all attempts, use airbyte_get_job_logs. - On Airbyte Cloud (internal API not available).

Returns: JSON with attempt metadata and structured log entries, truncated to the last tail_lines entries.

Examples: params = { "job_id": 12345, "attempt_number": 0 } params = { "job_id": 12345, "attempt_number": 2, "tail_lines": 500 }

List sync and reset jobs with rich filtering options.

Jobs represent individual sync or reset executions. Every time a connection runs (manually or on schedule), Airbyte creates a job that tracks status, duration, bytes synced, and rows synced.

When to Use: - Check recent sync activity for a specific connection. - Find failed or running jobs across workspaces. - Audit sync volume (bytes/rows) over a date range. - Monitor whether scheduled syncs are executing on time.

When NOT to Use: - If you already have a job ID, use airbyte_get_job for full details. - To see pipeline definitions (schedule, streams), use airbyte_get_connection instead.

Filters: All filters are optional and combinable: - connection_id: restrict to one pipeline. - workspace_ids: restrict to specific workspaces. - job_type: "sync" or "reset". - status: pending, running, incomplete, failed, succeeded, or cancelled. - created_at_start / created_at_end: ISO-8601 date range (e.g. "2024-01-01T00:00:00Z"). - order_by: sort field, e.g. "createdAt|DESC" (default).

Returns: Paginated list of jobs. Each entry includes: - jobId, jobType, status, connectionId, startTime, duration, bytesSynced, rowsSynced.

Markdown format shows a heading per job with bullet fields.
JSON format returns the raw API response array.

Pagination: Use limit (1–100, default 20) and offset (default 0).

Examples: Recent failed jobs for a connection: params = { "connection_id": "a1b2c3d4-...", "status": "failed", "limit": 5 } All sync jobs in the last 7 days: params = { "job_type": "sync", "created_at_start": "2024-06-01T00:00:00Z" } Latest 3 jobs, newest first: params = { "limit": 3, "order_by": "createdAt|DESC" }

Get full details of a single sync or reset job by its numeric ID.

Returns the job status, type, associated connection, start time, duration, and volume metrics (bytes and rows synced). Use this to inspect a specific job's outcome.

When to Use: - Check whether a specific job succeeded or failed. - Get precise bytes/rows synced for a particular run. - Inspect job duration for performance analysis. - Follow up on a job ID returned by airbyte_list_jobs.

When NOT to Use: - If you need to browse multiple jobs, use airbyte_list_jobs with filters. - To see the pipeline definition (schedule, streams), use airbyte_get_connection instead.

Returns: Job details including: jobId, jobType, status, connectionId, startTime, duration, bytesSynced, rowsSynced.

Markdown format renders a heading with bullet-point fields.
JSON format returns the full API response object.

Examples: Get job by ID: params = { "job_id": "12345" } Get raw JSON: params = { "job_id": "12345", "response_format": "json" }

Error Handling: Returns a 404 message if the job ID does not exist.

Trigger a sync or reset job for a connection.

Starts a new job that replicates data from source to destination (sync) or clears destination data and re-syncs (reset).

When to Use: - Manually kick off a sync outside the regular schedule. - Trigger a reset after schema changes or data issues. - Automate syncs in response to upstream events.

When NOT to Use: - The connection is already running a sync (check with airbyte_list_jobs first).

Returns: The newly created job with its jobId and initial status.

Examples: Trigger a sync: params = { "connection_id": "a1b2c3d4-..." } Trigger a reset: params = { "connection_id": "a1b2c3d4-...", "job_type": "reset" }

Cancel a running sync or reset job.

Sends a cancellation request to the Airbyte API. The job will transition to 'cancelled' status. Already-committed data is retained; only in-flight data is discarded.

When to Use: - Stop a long-running or stuck sync. - Cancel an accidental reset.

Returns: The cancelled job's details.

Examples: params = { "job_id": "12345" }

List source connectors configured in Airbyte.

Sources represent the data origins (databases, APIs, SaaS apps, etc.) that Airbyte reads from. Each source is linked to a workspace and can be paired with one or more destinations via connections.

When to Use: - Discover which source connectors are set up. - Find a source's UUID to inspect its configuration or look up related connections. - Audit sources across one or more workspaces.

When NOT to Use: - If you already have a source ID, use airbyte_get_source for full details. - To see what data a source actually moves, look at connections (airbyte_list_connections) or jobs (airbyte_list_jobs).

Returns: Paginated list of sources. Each entry includes: - name, sourceId (UUID), sourceType, workspaceId, createdAt.

Markdown format shows a heading per source with bullet fields.
JSON format returns the raw API response array.

Pagination: Use limit (1–100, default 20) and offset (default 0).

Examples: List all sources in a workspace: params = { "workspace_ids": ["a1b2c3d4-..."] } List first 5 sources across all workspaces: params = { "limit": 5 } Include soft-deleted sources: params = { "include_deleted": true }

Get full details of a single source connector by its UUID.

Returns the source name, type (e.g. postgres, stripe, google-sheets), workspace, creation date, and connector configuration. Secrets in the configuration object are masked by the Airbyte API.

When to Use: - Inspect a specific source's configuration or connector type. - Verify a source ID is valid. - Check when a source was created or which workspace owns it.

When NOT to Use: - If you need to browse sources, use airbyte_list_sources. - To see sync activity, use airbyte_list_jobs filtered by the connection that uses this source.

Returns: Source details including: name, sourceId, sourceType, workspaceId, createdAt, and configuration (secrets masked).

Markdown format renders a heading with bullet-point fields.
JSON format returns the full API response object.

Examples: Get source by ID: params = { "source_id": "a1b2c3d4-..." } Get raw JSON: params = { "source_id": "a1b2c3d4-...", "response_format": "json" }

Error Handling: Returns a 404 message if the source ID does not exist.

Create a new source connector in Airbyte.

A source defines where Airbyte reads data from (a database, API, SaaS app, etc.). Each source type requires its own configuration schema (e.g. host, port, credentials for Postgres).

When to Use: - Set up a brand-new data source inside a workspace. - Automate provisioning of sources as part of a pipeline setup.

Recommended Workflow: 1. Call airbyte_list_source_definitions to find the definition ID for the connector type you want (e.g. "source-postgres"). 2. Review an existing source of the same type with airbyte_get_source to understand the configuration structure. 3. Call this tool with the appropriate configuration.

Returns: The created source details (same fields as airbyte_get_source).

Examples: params = { "name": "Production Postgres", "workspace_id": "a1b2c3d4-...", "definition_id": "decd338e-...", "configuration": { "sourceType": "postgres", "host": "db.example.com", "port": 5432, "database": "mydb", "username": "readonly", "password": "secret" } }

Update an existing source connector's name or configuration.

Uses PATCH semantics: only the fields you provide are changed. The configuration object is merged at the top level by the API.

When to Use: - Change connection credentials (e.g. rotate a password). - Rename a source for clarity. - Update connector settings (e.g. change replication slot).

Recommended Workflow: 1. Call airbyte_get_source to see the current configuration. 2. Build the updated configuration with only the changed fields. 3. Call this tool.

Returns: The updated source details.

Examples: Rename a source: params = { "source_id": "a1b2c3d4-...", "name": "New Name" } Update configuration: params = { "source_id": "a1b2c3d4-...", "configuration": { "password": "new-secret" } }

Get the available streams and their properties for a source.

Returns the list of streams that the source connector can produce, along with each stream's supported sync modes, default cursor field, and source-defined primary key.

When to Use: - Before creating a connection, to discover which streams are available and which sync modes they support. - To verify that a source has the expected streams after configuration changes. - To find the right cursor field or primary key for incremental syncs.

When NOT to Use: - To see which streams are currently configured on a connection, use airbyte_get_connection instead.

Returns: List of streams with: name, namespace, sync modes, default cursor field, and primary key.

Examples: Basic usage: params = { "source_id": "a1b2c3d4-..." } With destination context and cache bypass: params = { "source_id": "a1b2c3d4-...", "destination_id": "e5f6g7h8-...", "ignore_cache": true }

List all tags in Airbyte.

Tags are labels that can be attached to resources (connections, sources, destinations) for organization and filtering.

When to Use: - Discover existing tags before creating a new one. - Get tag IDs for use in filtering or management.

Returns: List of tags with name and tagId.

Create a new tag in Airbyte.

When to Use: - Add a new organizational label for resources.

Returns: The created tag with its tagId.

Examples: params = { "name": "production" }

Update an existing tag's name.

When to Use: - Rename a tag for better organization.

Returns: The updated tag.

Examples: params = { "tag_id": "a1b2c3d4-...", "name": "staging" }

Delete a tag by its UUID.

This is a permanent operation. The tag will be removed from all resources it was attached to.

When to Use: - Remove an obsolete or duplicate tag.

Examples: params = { "tag_id": "a1b2c3d4-..." }

List all Airbyte workspaces the current credentials have access to.

Workspaces are the top-level organizational unit in Airbyte. Every source, destination, and connection belongs to exactly one workspace. Use this tool to discover workspace IDs before filtering other resources.

When to Use: - Discover which workspaces exist and get their UUIDs. - Find a workspace by name to use its ID in other calls. - Audit workspace configuration (data residency, etc.).

When NOT to Use: - If you already have a workspace ID, use airbyte_get_workspace for full details instead.

Returns: Paginated list of workspaces. Each entry includes: - name, workspaceId (UUID), dataResidency.

Markdown format shows a heading per workspace.
JSON format returns the raw API response array.

Pagination: Use limit (1–100, default 20) and offset (default 0). The response header indicates whether more pages exist.

Examples: List first 5 workspaces: params = { "limit": 5 } List including deleted workspaces: params = { "include_deleted": true } Get raw JSON for scripting: params = { "response_format": "json" }

Get full details of a single Airbyte workspace by its UUID.

Returns the workspace name, data residency region, and other metadata. Use when you already know the workspace ID and need its properties.

When to Use: - Look up a specific workspace's name or data residency. - Confirm a workspace ID is valid before passing it to other tools.

When NOT to Use: - If you need to browse or search workspaces, use airbyte_list_workspaces instead.

Returns: Workspace details including: name, workspaceId, dataResidency.

Markdown format renders a heading with bullet-point fields.
JSON format returns the full API response object.

Examples: Get workspace by ID: params = { "workspace_id": "a1b2c3d4-..." } Get raw JSON: params = { "workspace_id": "a1b2c3d4-...", "response_format": "json" }

Error Handling: Returns a 404 message if the workspace ID does not exist. Returns a 403 message if credentials lack access to that workspace.