> ## 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.

# Prediction

> Forecast a wide range of time series data in seconds with one simple API and no data training.

## Request Parameters

### Body

<ParamField body="dataset" type="Array<object>" required>
  The dataset to make predictions on. This is an array of objects with keys
  `date` and `value`. See example below for more information.

  <Note>
    The `date` parameter must be in `YYYY-MM-DD` format (e.g., "2023-01-01").
  </Note>

  * Minimum: 5 data points
  * Maximum: 1000 data points

  Note: The larger the dataset provided, the more accurate the predictions become.
  For best results, provide at least 20-30 data points with consistent intervals.

  <Expandable title="Dataset Object Properties">
    <ParamField body="value" type="number | string" required>
      The numeric value for the data point.
    </ParamField>

    <ParamField body="date" type="string" required>
      The date for the data point in `YYYY-MM-DD` format (e.g., "2023-01-01").
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="steps" type="number" default="5">
  The number of predictions to make. - Minimum: 1 - Maximum: 500
</ParamField>

### Sample Dataset

> A dataset must be an array of object containing keys `date` and `value`.

```javascript theme={null}
type Dataset = {
  date: string,
  value: number | string,
};

const dataset: Array<Dataset> = [
  { date: "2023-01-01", value: 353459 },
  { date: "2023-01-02", value: 313734 },
  { date: "2023-01-03", value: 333774 },
  { date: "2023-01-04", value: 348636 },
  { date: "2023-01-05", value: 278903 },
];
```

<Snippet file="header.mdx" />

## Response Structure

<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>

<ResponseField name="prediction" type="Array<object>">
  Array of predicted data points with the same structure as the input dataset.

  <Expandable title="Prediction Object Properties">
    <ResponseField name="date" type="string">
      The date for the predicted data point in `YYYY-MM-DD` format.
    </ResponseField>

    <ResponseField name="value" type="number">
      The predicted numeric value for this data point.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="steps" type="number">
  The number of prediction steps.
</ResponseField>

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

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

  const response = await jigsaw.prediction({
    "dataset": [
          {
                "date": "2023-01-01",
                "value": 353459
          },
          {
                "date": "2023-01-02",
                "value": 313734
          },
          {
                "date": "2023-01-03",
                "value": 333774
          },
          {
                "date": "2023-01-04",
                "value": 348636
          },
          {
                "date": "2023-01-05",
                "value": 278903
          }
    ],
    "steps": 3
  })
  ```

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

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

  response = jigsaw.prediction({
    "dataset": [
          {
                "date": "2023-01-01",
                "value": 353459
          },
          {
                "date": "2023-01-02",
                "value": 313734
          },
          {
                "date": "2023-01-03",
                "value": 333774
          },
          {
                "date": "2023-01-04",
                "value": 348636
          },
          {
                "date": "2023-01-05",
                "value": 278903
          }
    ],
    "steps": 3
  })
  ```

  ```bash Curl theme={null}
  curl https://api.jigsawstack.com/v1/ai/prediction \
  -X POST \
  -H 'Content-Type: application/json' \
  -H 'x-api-key: your-api-key' \
  -d '{"dataset":[{"date":"2023-01-01","value":353459},{"date":"2023-01-02","value":313734},{"date":"2023-01-03","value":333774},{"date":"2023-01-04","value":348636},{"date":"2023-01-05","value":278903}],"steps":3}'
  ```

  ```php PHP theme={null}
  <?php
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, 'https://api.jigsawstack.com/v1/ai/prediction');
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'Content-Type: application/json',
  'x-api-key: your-api-key',
  ]);
  curl_setopt($ch, CURLOPT_POSTFIELDS, '{"dataset":[{"date":"2023-01-01","value":353459},{"date":"2023-01-02","value":313734},{"date":"2023-01-03","value":333774},{"date":"2023-01-04","value":348636},{"date":"2023-01-05","value":278903}],"steps":3}');

  $response = curl_exec($ch);

  curl_close($ch);

  ```

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

  uri = URI('https://api.jigsawstack.com/v1/ai/prediction')
  req = Net::HTTP::Post.new(uri)
  req.content_type = 'application/json'
  req['x-api-key'] = 'your-api-key'

  req.body = {
  'dataset' => [
  {
    'date' => '2023-01-01',
    'value' => 353459
  },
  {
    'date' => '2023-01-02',
    'value' => 313734
  },
  {
    'date' => '2023-01-03',
    'value' => 333774
  },
  {
    'date' => '2023-01-04',
    'value' => 348636
  },
  {
    'date' => '2023-01-05',
    'value' => 278903
  }
  ],
  'steps' => 3
  }.to_json

  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"
  "strings"
  )

  func main() {
  client := &http.Client{}
  var data = strings.NewReader(`{"dataset":[{"date":"2023-01-01","value":353459},{"date":"2023-01-02","value":313734},{"date":"2023-01-03","value":333774},{"date":"2023-01-04","value":348636},{"date":"2023-01-05","value":278903}],"steps":3}`)
  req, err := http.NewRequest("POST", "https://api.jigsawstack.com/v1/ai/prediction", data)
  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.HttpRequest.BodyPublishers;
  import java.net.http.HttpResponse;

  HttpClient client = HttpClient.newHttpClient();

  HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.jigsawstack.com/v1/ai/prediction"))
  .POST(BodyPublishers.ofString("{\"dataset\":[{\"date\":\"2023-01-01\",\"value\":353459},{\"date\":\"2023-01-02\",\"value\":313734},{\"date\":\"2023-01-03\",\"value\":333774},{\"date\":\"2023-01-04\",\"value\":348636},{\"date\":\"2023-01-05\",\"value\":278903}],\"steps\":3}"))
  .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 jsonData = [
  "dataset": [
      [
          "date": "2023-01-01",
          "value": 353459
      ],
      [
          "date": "2023-01-02",
          "value": 313734
      ],
      [
          "date": "2023-01-03",
          "value": 333774
      ],
      [
          "date": "2023-01-04",
          "value": 348636
      ],
      [
          "date": "2023-01-05",
          "value": 278903
      ]
  ],
  "steps": 3
  ] as [String : Any]
  let data = try! JSONSerialization.data(withJSONObject: jsonData, options: [])

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

  var request = URLRequest(url: url)
  request.httpMethod = "POST"
  request.allHTTPHeaderFields = headers
  request.httpBody = data as Data

  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 data = '{"dataset":[{"date":"2023-01-01","value":353459},{"date":"2023-01-02","value":313734},{"date":"2023-01-03","value":333774},{"date":"2023-01-04","value":348636},{"date":"2023-01-05","value":278903}],"steps":3}';

  final url = Uri.parse('https://api.jigsawstack.com/v1/ai/prediction');

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

  print(res.body);
  }

  ```

  ```kotlin Kotlin theme={null}
  import java.io.IOException
  import okhttp3.MediaType.Companion.toMediaType
  import okhttp3.OkHttpClient
  import okhttp3.Request
  import okhttp3.RequestBody.Companion.toRequestBody

  val client = OkHttpClient()

  val MEDIA_TYPE = "application/json".toMediaType()

  val requestBody = "{\"dataset\":[{\"date\":\"2023-01-01\",\"value\":353459},{\"date\":\"2023-01-02\",\"value\":313734},{\"date\":\"2023-01-03\",\"value\":333774},{\"date\":\"2023-01-04\",\"value\":348636},{\"date\":\"2023-01-05\",\"value\":278903}],\"steps\":3}"

  val request = Request.Builder()
  .url("https://api.jigsawstack.com/v1/ai/prediction")
  .post(requestBody.toRequestBody(MEDIA_TYPE))
  .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.Post, "https://api.jigsawstack.com/v1/ai/prediction");
  request.Headers.Add("x-api-key", "your-api-key");
  request.Content = JsonContent.Create(new
  {
  dataset = new List<object> { {"date":"2023-01-01","value":353459}, {"date":"2023-01-02","value":313734}, {"date":"2023-01-03","value":333774}, {"date":"2023-01-04","value":348636}, {"date":"2023-01-05","value":278903} },
  steps = 3
  });
  request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

  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,
    "prediction": [
          {
                "date": "2023-01-08 00:00:00",
                "value": 315214.5625
          },
          {
                "date": "2023-01-07 00:00:00",
                "value": 320094.71875
          },
          {
                "date": "2023-01-06 00:00:00",
                "value": 316329.9375
          }
    ],
    "steps": 3,
    "_usage": {
          "input_tokens": 53,
          "output_tokens": 49,
          "inference_time_tokens": 1992,
          "total_tokens": 2094
    }
  }
  ```
</ResponseExample>