> ## Documentation Index
> Fetch the complete documentation index at: https://docs.runalloy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Retrieve logs for a single workflow

> Retrieves log data for a given workflow.
Each log includes the `executionId` (which can be used to rerun an execution), the `startedAt` and `stoppedAt` date stamps, and the JSON output of the execution.



## OpenAPI

````yaml get /workflows/{workflowId}/logs
openapi: 3.0.1
info:
  title: Embedded 2025-09
  version: '5.0'
servers:
  - url: https://production.runalloy.com
security: []
paths:
  /workflows/{workflowId}/logs:
    get:
      summary: Retrieve logs for a single workflow
      description: >-
        Retrieves log data for a given workflow.

        Each log includes the `executionId` (which can be used to rerun an
        execution), the `startedAt` and `stoppedAt` date stamps, and the JSON
        output of the execution.
      operationId: get-workflow-logs
      parameters:
        - name: Authorization
          in: header
          required: true
          schema:
            type: string
            default: bearer YOUR_API_KEY
        - $ref: '#/components/parameters/xApiVersion'
        - name: workflowId
          in: path
          description: The Id of the git workflow you want to find logs for
          schema:
            type: string
          required: true
        - name: userId
          in: query
          description: >-
            The Id of the user you want delete logs for. Returned from the
            Create User endpoint
          schema:
            type: string
        - name: page
          in: query
          description: page of results
          schema:
            type: integer
            format: int32
        - name: limit
          in: query
          description: Number of results per page (max 30, default 10)
          schema:
            type: integer
            format: int32
        - name: order
          in: query
          description: asc or desc for ascending/descending (default desc)
          schema:
            type: string
      responses:
        '200':
          description: '200'
          content:
            application/json:
              examples:
                Result:
                  value:
                    data:
                      - executionId: uGmauA50FBlibba3JkPfB
                        startedAt: '2024-11-15T17:57:42.233Z'
                        stoppedAt: '2024-11-15T17:57:42.847Z'
                        finished: true
                        results:
                          - startedAt: '2024-11-15T17:57:42.233Z'
                            stoppedAt: '2024-11-15T17:57:42.287Z'
                            data:
                              - - json: {}
                                  id: 1e2ef00f-af4c-405e-88b7-c71536d28ddd
                            connectorId: 6ad63c40-1abc-4289-8287-c62ef8bb2003
                          - startedAt: '2024-11-15T17:57:42.391Z'
                            data:
                              - - json: null
                                  profileId:
                                    type: profile
                                    id: 01F1EQ9A32KABYFC7Q0QNNHH33
                                    attributes:
                                      email: gregg@runalloy.com
                                      phone_number: '+12394750599'
                                      external_id: null
                                    relationships:
                                      lists:
                                        links:
                                          self: >-
                                            https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/relationships/lists/
                                          related: >-
                                            https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/lists/
                                      segments:
                                        links:
                                          self: >-
                                            https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/relationships/segments/
                                          related: >-
                                            https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/segments/
                                      conversation:
                                        links:
                                          self: >-
                                            https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/relationships/conversation/
                                          related: >-
                                            https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/conversation/
                                    links:
                                      self: >-
                                        https://a.klaviyo.com/api/profiles/01F1EQ9A32KABYFC7Q0QNNHH33/
                                  statusCode: 200
                                  id: a6c68f48-4ef0-4d16-a009-3b47db6f611f
                            stoppedAt: '2024-11-15T17:57:42.781Z'
                            connectorId: ae331681-25a5-452c-8d21-884fada67437
                        inputs:
                          - connectorId: 6ad63c40-1abc-4289-8287-c62ef8bb2003
                            data: {}
                          - connectorId: ae331681-25a5-452c-8d21-884fada67437
                            data:
                              apiVersion: legacy
                              profileFrom: emailAddress
                              email: gregg@runalloy.com
      deprecated: false
      security: []
      x-code-samples:
        - lang: cURL
          source: >
            curl -X GET
            "https://production.runalloy.com/workflows/{workflowId}/logs?userId={{userId}}"
            \
              -H "Authorization: bearer YOUR_API_KEY" \
              -H "x-api-version: 2025-09"
        - lang: Python
          source: |
            import requests

            url = "https://production.runalloy.com/workflows/{workflowId}/logs"
            params = {"userId": "{{userId}}"}
            headers = {
                "Authorization": "bearer YOUR_API_KEY",
                "x-api-version": "2025-09"
            }

            response = requests.get(url, params=params, headers=headers)
            print(response.json())
        - lang: JavaScript
          source: >
            const userId = "{{userId}}";

            const workflowId = "{workflowId}";

            const url =
            `https://production.runalloy.com/workflows/${workflowId}/logs?userId=${userId}`;


            fetch(url, {
              method: "GET",
              headers: {
                "Authorization": "bearer YOUR_API_KEY",
                "x-api-version": "2025-09"
              }
            })
              .then(response => response.json())
              .then(data => console.log(data))
              .catch(error => console.error("Error:", error));
        - lang: PHP
          source: >
            <?php

            $userId = "{{userId}}";

            $workflowId = "{workflowId}";

            $url =
            "https://production.runalloy.com/workflows/{$workflowId}/logs?userId="
            . urlencode($userId);


            $ch = curl_init($url);

            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

            curl_setopt($ch, CURLOPT_HTTPHEADER, [
                "Authorization: bearer YOUR_API_KEY",
                "x-api-version: 2025-09"
            ]);


            $response = curl_exec($ch);

            curl_close($ch);

            $data = json_decode($response, true);

            print_r($data);

            ?>
        - lang: Go
          source: |
            package main

            import (
                "encoding/json"
                "fmt"
                "io"
                "net/http"
                "net/url"
            )

            func main() {
                userId := "{{userId}}"
                workflowId := "{workflowId}"
                baseURL := "https://production.runalloy.com/workflows/" + workflowId + "/logs"
                params := url.Values{}
                params.Add("userId", userId)
                fullURL := baseURL + "?" + params.Encode()

                req, _ := http.NewRequest("GET", fullURL, nil)
                req.Header.Set("Authorization", "bearer YOUR_API_KEY")
                req.Header.Set("x-api-version", "2025-09")

                client := &http.Client{}
                resp, _ := client.Do(req)
                defer resp.Body.Close()

                body, _ := io.ReadAll(resp.Body)
                var data map[string]interface{}
                json.Unmarshal(body, &data)
                fmt.Println(data)
            }
        - lang: Java
          source: |
            import java.net.HttpURLConnection;
            import java.net.URL;
            import java.io.BufferedReader;
            import java.io.InputStreamReader;
            import com.google.gson.Gson;
            import java.util.Map;

            public class Example {
                public static void main(String[] args) throws Exception {
                    String userId = "{{userId}}";
                    String workflowId = "{workflowId}";
                    String baseUrl = "https://production.runalloy.com/workflows/" + workflowId + "/logs";
                    String urlString = baseUrl + "?userId=" + java.net.URLEncoder.encode(userId, "UTF-8");
                    
                    URL url = new URL(urlString);
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    conn.setRequestMethod("GET");
                    conn.setRequestProperty("Authorization", "bearer YOUR_API_KEY");
                    conn.setRequestProperty("x-api-version", "2025-09");
                    
                    BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                    String inputLine;
                    StringBuilder response = new StringBuilder();
                    while ((inputLine = in.readLine()) != null) {
                        response.append(inputLine);
                    }
                    in.close();
                    
                    Gson gson = new Gson();
                    Map<String, Object> data = gson.fromJson(response.toString(), Map.class);
                    System.out.println(data);
                }
            }
        - lang: Ruby
          source: >
            require 'net/http'

            require 'json'

            require 'uri'


            userId = "{{userId}}"

            workflowId = "{workflowId}"

            base_url =
            "https://production.runalloy.com/workflows/#{workflowId}/logs"

            uri = URI(base_url)

            params = { userId: userId }

            uri.query = URI.encode_www_form(params)


            http = Net::HTTP.new(uri.host, uri.port)

            http.use_ssl = true


            request = Net::HTTP::Get.new(uri)

            request['Authorization'] = 'bearer YOUR_API_KEY'

            request['x-api-version'] = '2025-09'


            response = http.request(request)

            data = JSON.parse(response.body)

            puts data
components:
  parameters:
    xApiVersion:
      name: x-api-version
      in: header
      required: true
      description: The version of the API to use. The current API version is **2025-09**.
      schema:
        type: string
        default: 2025-09

````