# Working with Logs

Logs help you understand what happens during the execution of your flows. They provide insight into configuration, request details, responses, errors, and the overall progress of each step.

By learning how to read logs, you can troubleshoot issues, verify your setup, and ensure your flows are working as expected.

### Finding and Filtering Logs

When viewing logs for a flow execution, you can:

* **Filter by time range** – focus on executions within a specific period.
* **Filter by step** – see what happened in one particular step of the flow.

This makes it easier to zoom in on the exact execution you want to analyze.

<figure><img src="/files/57qVe8yxNMa4jA3GCUyW" alt=""><figcaption></figcaption></figure>

### Key Types of Log Information

Logs contain different types of messages. Here are the most important categories:

#### Configuration & Settings

These logs show how the flow and steps were configured at the time of execution. Examples include:

* **Pagination config** – how multiple pages of data are fetched.
* **Trigger settings** – which snapshot key or parameters are being used.

Example:

{% code overflow="wrap" %}

```json
Trigger settings - "snapshotKey": attributes.last_modified_at.value, "arraySplittingKey": data, "syncParam": updated_since, "skipSnapshot": undefined
```

{% endcode %}

* **snapshotKey** – the field FlowMate uses to remember the *last processed timestamp* (e.g., `last_modified_at`). On the next run, only newer data will be fetched.
* **arraySplittingKey** – tells FlowMate which field contains the list of objects that should be split into individual items.
* **syncParam** – the parameter sent to the API to request “only changes since last run” (e.g., `updated_since`).

&#x20;These logs are mostly informational. They show you **what the flow is using internally** to decide which data to fetch and how to process it.

#### Snapshot and Sync Param

Snapshots store the state of the flow between executions. Logs may show:

* Which snapshot was used when starting.
* What snapshot was generated and saved at the end.

This is especially important for incremental syncs (e.g., “updated since last run”).

```json
A new snapshot was emitted: {"lastUpdated":"2025-07-29T13:14:50+02:00"}
```

#### API Responses

Logs also capture the response from external systems:

* **Status code** (e.g., `200` for success, `400` or `500` for errors).
* **URL** that was called.
* **Headers** returned.
* **Number of items** received.

This helps verify whether the system accepted your request and what data came back.

{% code overflow="wrap" %}

```json
Swagger response {"status":200,"url":"https://api.personio.de/v1/company/employees?limit=200&updated_since=2025-07-29T11%3A14%3A50Z"...
```

{% endcode %}

#### Final Call Params

These logs display the **exact request** sent to an external system. They include:

* HTTP method (GET, POST, etc.)
* Endpoint path (e.g., `/company/employees`)
* Query parameters (e.g., `limit`, `offset`)
* Request body (e.g., contact data in a POST request)

Example for a Trigger:

{% code overflow="wrap" %}

```json
Final Call params: {"spec":"[omitted]","pathName":"/company/employees","method":"get","parameters":{"updated_since":"2025-07-29T11:14:50Z","limit":200},"securities":"[omitted]","server":""}
```

{% endcode %}

Example for a POST Request:

{% code overflow="wrap" %}

```json
Final Call params: {"spec":"[omitted]","pathName":"/contacts","method":"post","parameters":{},"requestContentType":"application/json","requestBody":{"personType":"private_person","firstName":"Cristi","lastName":"Widmer","email":"cristi.widmer@demo-sample.com"},"securities":"[omitted]","server":""}
```

{% endcode %}

#### Execution Flow

FlowMate logs also track the overall execution steps, for example:

* Starting a trigger or action.
* Number of items found in the response.
* Number of items emitted to the next step.
* Whether all pages of data were received.
* Execution finished.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://flowmate.gitbook.io/flowmate-documentation/working-with-logs.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.