> ## Documentation Index
> Fetch the complete documentation index at: https://jigsaw-13.mintlify.app/llms.txt
> Use this file to discover all available pages before exploring further.

# List Prompts

> List all prompts in your project.

<Note>
  🎉 **Exciting News!** We've enhanced Prompt Engine with powerful new capabilities. Meet [Interfaze](https://interfaze.ai) - our advanced LLM that takes your AI workflows to the next level, built for debvelopers, with improved performance
  better organization, and enhanced features.
</Note>

<Snippet file="header.mdx" />

### Query

<ParamField query="limit" default="30" type="string">
  The maximum number of prompts to be returned.
</ParamField>

<ParamField query="page" default="1" type="string">
  The page to return.
</ParamField>

<Snippet file="header.mdx" />

### Response

<ResponseField name="success" type="boolean">
  Indicates whether the call was successful.
</ResponseField>

<ResponseField name="_usage" type="object" optional>
  Usage information for the API call.

  <Expandable title="_usage">
    <ResponseField name="input_tokens" type="number">
      Number of input tokens processed.
    </ResponseField>

    <ResponseField name="output_tokens" type="number">
      Number of output tokens generated.
    </ResponseField>

    <ResponseField name="inference_time_tokens" type="number">
      Number of tokens processed during inference time.
    </ResponseField>

    <ResponseField name="total_tokens" type="number">
      Total number of tokens used (input + output).
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="log_id" type="string" optional>
  A unique identifier for the request
</ResponseField>

<RequestExample>
  ```javascript Javascript theme={null}
  import { JigsawStack } from "jigsawstack";

  const jigsaw = JigsawStack({ apiKey: "your-api-key" });

  const response = await jigsaw.prompt_engine.list({
    "limit": "10"
  })
  ```

  ```python Python theme={null}
  from jigsawstack import JigsawStack

  jigsaw = JigsawStack(api_key="your-api-key")

  response = jigsaw.prompt_engine.list({
    "limit": "10"
  })
  ```

  ```bash Curl theme={null}
  curl https://api.jigsawstack.com/v1/prompt_engine?limit=10 \
  -X GET \
  -H 'Content-Type: application/json' \
  -H 'x-api-key: your-api-key'
  ```

  ```php PHP theme={null}
  <?php
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, 'https://api.jigsawstack.com/v1/prompt_engine?limit=10');
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'Content-Type: application/json',
  'x-api-key: your-api-key',
  ]);

  $response = curl_exec($ch);

  curl_close($ch);

  ```

  ```ruby Ruby theme={null}
  require 'net/http'

  uri = URI('https://api.jigsawstack.com/v1/prompt_engine')
  params = {
  :limit => '10',
  }
  uri.query = URI.encode_www_form(params)

  req = Net::HTTP::Get.new(uri)
  req.content_type = 'application/json'
  req['x-api-key'] = 'your-api-key'

  req_options = {
  use_ssl: uri.scheme == 'https'
  }
  res = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(req)
  end

  ```

  ```go Go theme={null}
  package main

  import (
  "fmt"
  "io"
  "log"
  "net/http"
  )

  func main() {
  client := &http.Client{}
  req, err := http.NewRequest("GET", "https://api.jigsawstack.com/v1/prompt_engine?limit=10", nil)
  if err != nil {
  	log.Fatal(err)
  }
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("x-api-key", "your-api-key")
  resp, err := client.Do(req)
  if err != nil {
  	log.Fatal(err)
  }
  defer resp.Body.Close()
  bodyText, err := io.ReadAll(resp.Body)
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Printf("%s\n", bodyText)
  }

  ```

  ```java Java theme={null}
  import java.io.IOException;
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;

  HttpClient client = HttpClient.newHttpClient();

  HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.jigsawstack.com/v1/prompt_engine?limit=10"))
  .GET()
  .setHeader("Content-Type", "application/json")
  .setHeader("x-api-key", "your-api-key")
  .build();

  HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

  ```

  ```swift Swift theme={null}
  import Foundation

  let url = URL(string: "https://api.jigsawstack.com/v1/prompt_engine?limit=10")!
  let headers = [
  "Content-Type": "application/json",
  "x-api-key": "your-api-key"
  ]

  var request = URLRequest(url: url)
  request.allHTTPHeaderFields = headers

  let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
  if let error = error {
      print(error)
  } else if let data = data {
      let str = String(data: data, encoding: .utf8)
      print(str ?? "")
  }
  }

  task.resume()

  ```

  ```dart Dart theme={null}
  import 'package:http/http.dart' as http;

  void main() async {
  final headers = {
  'Content-Type': 'application/json',
  'x-api-key': 'your-api-key',
  };

  final params = {
  'limit': '10',
  };

  final url = Uri.parse('https://api.jigsawstack.com/v1/prompt_engine')
    .replace(queryParameters: params);

  final res = await http.get(url, headers: headers);
  final status = res.statusCode;
  if (status != 200) throw Exception('http.get error: statusCode= $status');

  print(res.body);
  }

  ```

  ```kotlin Kotlin theme={null}
  import java.io.IOException
  import okhttp3.OkHttpClient
  import okhttp3.Request

  val client = OkHttpClient()

  val request = Request.Builder()
  .url("https://api.jigsawstack.com/v1/prompt_engine?limit=10")
  .header("Content-Type", "application/json")
  .header("x-api-key", "your-api-key")
  .build()

  client.newCall(request).execute().use { response ->
  if (!response.isSuccessful) throw IOException("Unexpected code $response")
  response.body!!.string()
  }

  ```

  ```csharp C# theme={null}
  using System.Net.Http.Headers;
  using System.Net.Http.Json;

  HttpClient client = new HttpClient();

  HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "https://api.jigsawstack.com/v1/prompt_engine?limit=10");
  request.Headers.Add("x-api-key", "your-api-key");

  HttpResponseMessage response = await client.SendAsync(request);
  response.EnsureSuccessStatusCode();
  string responseBody = await response.Content.ReadAsStringAsync();

  Console.WriteLine(responseBody);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "success": true,
    "prompt_engines": [
          {
                "id": "0317e3c5-b441-42de-9bce-19d76812e459",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-15T22:31:54.575163+00:00"
          },
          {
                "id": "2fc1fa81-e7b4-4539-bc35-7a4349b61601",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-15T22:19:05.416393+00:00"
          },
          {
                "id": "a4622068-2b84-47b3-a325-13c7a82ca393",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-10T18:34:27.004408+00:00"
          },
          {
                "id": "5c3c2736-17e1-4536-9ccf-e8d72ca483f1",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-09T18:20:43.778267+00:00"
          },
          {
                "id": "278515ab-23cb-4675-8041-614f0d268c68",
                "prompt": "Tell me a story about {about}",
                "inputs": null,
                "return_prompt": null,
                "return_prompt_type": "string",
                "created_at": "2025-09-09T02:49:00.296775+00:00"
          },
          {
                "id": "12ca390e-0eb6-4bf2-a727-67f2ef79cd39",
                "prompt": "Tell me a story about {about}",
                "inputs": null,
                "return_prompt": null,
                "return_prompt_type": "string",
                "created_at": "2025-09-09T02:48:13.305085+00:00"
          },
          {
                "id": "48ad4a83-82c9-4356-89f4-c48e43fa6b81",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-09T02:37:53.155681+00:00"
          },
          {
                "id": "c62d8a22-d75c-4d9f-b4ee-5673f154be76",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-09T02:37:32.744933+00:00"
          },
          {
                "id": "f2f3eb09-9754-4376-8824-c7231f3b2920",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-09T02:02:04.481774+00:00"
          },
          {
                "id": "85e919c1-717b-4b4f-9d0d-2e91968c102d",
                "prompt": "Tell me a story about {about}",
                "inputs": [
                      {
                            "key": "about",
                            "optional": false
                      }
                ],
                "return_prompt": "Return the result in a markdown format",
                "return_prompt_type": "string",
                "created_at": "2025-09-09T01:58:32.641838+00:00"
          }
    ],
    "page": 0,
    "limit": 10,
    "has_more": true,
    "_usage": {
          "input_tokens": 4,
          "output_tokens": 650,
          "inference_time_tokens": 151,
          "total_tokens": 805
    }
  }
  ```
</ResponseExample>