runtime
POST
Batch ML Predictions
{{baseUrl}}/v1/predict
BODY json
{
"predictions": [
{
"model_name": ""
}
]
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/predict");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/predict" {:content-type :json
:form-params {:predictions [{:model_name ""}]}})require "http/client"
url = "{{baseUrl}}/v1/predict"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/predict"),
Content = new StringContent("{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/predict");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/predict"
payload := strings.NewReader("{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/predict HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 61
{
"predictions": [
{
"model_name": ""
}
]
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/predict")
.setHeader("content-type", "application/json")
.setBody("{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/predict"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/predict")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/predict")
.header("content-type", "application/json")
.body("{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}")
.asString(); const data = JSON.stringify({
predictions: [
{
model_name: ''
}
]
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/predict');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/predict',
headers: {'content-type': 'application/json'},
data: {predictions: [{model_name: ''}]}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/predict';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"predictions":[{"model_name":""}]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/predict',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "predictions": [\n {\n "model_name": ""\n }\n ]\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/predict")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/predict',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({predictions: [{model_name: ''}]}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/predict',
headers: {'content-type': 'application/json'},
body: {predictions: [{model_name: ''}]},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/predict');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
predictions: [
{
model_name: ''
}
]
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/predict',
headers: {'content-type': 'application/json'},
data: {predictions: [{model_name: ''}]}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/predict';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"predictions":[{"model_name":""}]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"predictions": @[ @{ @"model_name": @"" } ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/predict"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/predict" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/predict",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'predictions' => [
[
'model_name' => ''
]
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/predict', [
'body' => '{
"predictions": [
{
"model_name": ""
}
]
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/predict');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'predictions' => [
[
'model_name' => ''
]
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'predictions' => [
[
'model_name' => ''
]
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/predict');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/predict' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"predictions": [
{
"model_name": ""
}
]
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/predict' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"predictions": [
{
"model_name": ""
}
]
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/predict", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/predict"
payload = { "predictions": [{ "model_name": "" }] }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/predict"
payload <- "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/predict")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/predict') do |req|
req.body = "{\n \"predictions\": [\n {\n \"model_name\": \"\"\n }\n ]\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/predict";
let payload = json!({"predictions": (json!({"model_name": ""}))});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/predict \
--header 'content-type: application/json' \
--data '{
"predictions": [
{
"model_name": ""
}
]
}'echo '{
"predictions": [
{
"model_name": ""
}
]
}' | \
http POST {{baseUrl}}/v1/predict \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "predictions": [\n {\n "model_name": ""\n }\n ]\n}' \
--output-document \
- {{baseUrl}}/v1/predictimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["predictions": [["model_name": ""]]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/predict")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"duration_ms": 81,
"predictions": [
{
"status": "Success",
"model_name": "drive_stats_a",
"model_version": "1.0",
"prediction": [
0.45,
0.5,
0.55
],
"duration_ms": 42
},
{
"status": "Success",
"model_name": "drive_stats_b",
"model_version": "1.0",
"prediction": [
0.43,
0.51,
0.53
],
"duration_ms": 42
}
]
}RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
An unexpected error occurred while processing batch predictions
POST
Create Chat Completion
{{baseUrl}}/v1/chat/completions
BODY json
{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/chat/completions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/chat/completions" {:content-type :json
:form-params {:audio ""
:frequency_penalty ""
:function_call ""
:functions ""
:logit_bias ""
:logprobs ""
:max_completion_tokens ""
:max_tokens ""
:messages []
:metadata ""
:modalities ""
:model ""
:n ""
:parallel_tool_calls ""
:prediction ""
:presence_penalty ""
:reasoning_effort ""
:response_format ""
:seed ""
:service_tier ""
:stop ""
:store ""
:stream ""
:stream_options ""
:temperature ""
:tool_choice ""
:tools ""
:top_logprobs ""
:top_p ""
:user ""
:web_search_options ""}})require "http/client"
url = "{{baseUrl}}/v1/chat/completions"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/chat/completions"),
Content = new StringContent("{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/chat/completions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/chat/completions"
payload := strings.NewReader("{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/chat/completions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 624
{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/chat/completions")
.setHeader("content-type", "application/json")
.setBody("{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/chat/completions"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/chat/completions")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/chat/completions")
.header("content-type", "application/json")
.body("{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}")
.asString(); const data = JSON.stringify({
audio: '',
frequency_penalty: '',
function_call: '',
functions: '',
logit_bias: '',
logprobs: '',
max_completion_tokens: '',
max_tokens: '',
messages: [],
metadata: '',
modalities: '',
model: '',
n: '',
parallel_tool_calls: '',
prediction: '',
presence_penalty: '',
reasoning_effort: '',
response_format: '',
seed: '',
service_tier: '',
stop: '',
store: '',
stream: '',
stream_options: '',
temperature: '',
tool_choice: '',
tools: '',
top_logprobs: '',
top_p: '',
user: '',
web_search_options: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/chat/completions');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/chat/completions',
headers: {'content-type': 'application/json'},
data: {
audio: '',
frequency_penalty: '',
function_call: '',
functions: '',
logit_bias: '',
logprobs: '',
max_completion_tokens: '',
max_tokens: '',
messages: [],
metadata: '',
modalities: '',
model: '',
n: '',
parallel_tool_calls: '',
prediction: '',
presence_penalty: '',
reasoning_effort: '',
response_format: '',
seed: '',
service_tier: '',
stop: '',
store: '',
stream: '',
stream_options: '',
temperature: '',
tool_choice: '',
tools: '',
top_logprobs: '',
top_p: '',
user: '',
web_search_options: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/chat/completions';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"audio":"","frequency_penalty":"","function_call":"","functions":"","logit_bias":"","logprobs":"","max_completion_tokens":"","max_tokens":"","messages":[],"metadata":"","modalities":"","model":"","n":"","parallel_tool_calls":"","prediction":"","presence_penalty":"","reasoning_effort":"","response_format":"","seed":"","service_tier":"","stop":"","store":"","stream":"","stream_options":"","temperature":"","tool_choice":"","tools":"","top_logprobs":"","top_p":"","user":"","web_search_options":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/chat/completions',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "audio": "",\n "frequency_penalty": "",\n "function_call": "",\n "functions": "",\n "logit_bias": "",\n "logprobs": "",\n "max_completion_tokens": "",\n "max_tokens": "",\n "messages": [],\n "metadata": "",\n "modalities": "",\n "model": "",\n "n": "",\n "parallel_tool_calls": "",\n "prediction": "",\n "presence_penalty": "",\n "reasoning_effort": "",\n "response_format": "",\n "seed": "",\n "service_tier": "",\n "stop": "",\n "store": "",\n "stream": "",\n "stream_options": "",\n "temperature": "",\n "tool_choice": "",\n "tools": "",\n "top_logprobs": "",\n "top_p": "",\n "user": "",\n "web_search_options": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/chat/completions")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/chat/completions',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
audio: '',
frequency_penalty: '',
function_call: '',
functions: '',
logit_bias: '',
logprobs: '',
max_completion_tokens: '',
max_tokens: '',
messages: [],
metadata: '',
modalities: '',
model: '',
n: '',
parallel_tool_calls: '',
prediction: '',
presence_penalty: '',
reasoning_effort: '',
response_format: '',
seed: '',
service_tier: '',
stop: '',
store: '',
stream: '',
stream_options: '',
temperature: '',
tool_choice: '',
tools: '',
top_logprobs: '',
top_p: '',
user: '',
web_search_options: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/chat/completions',
headers: {'content-type': 'application/json'},
body: {
audio: '',
frequency_penalty: '',
function_call: '',
functions: '',
logit_bias: '',
logprobs: '',
max_completion_tokens: '',
max_tokens: '',
messages: [],
metadata: '',
modalities: '',
model: '',
n: '',
parallel_tool_calls: '',
prediction: '',
presence_penalty: '',
reasoning_effort: '',
response_format: '',
seed: '',
service_tier: '',
stop: '',
store: '',
stream: '',
stream_options: '',
temperature: '',
tool_choice: '',
tools: '',
top_logprobs: '',
top_p: '',
user: '',
web_search_options: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/chat/completions');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
audio: '',
frequency_penalty: '',
function_call: '',
functions: '',
logit_bias: '',
logprobs: '',
max_completion_tokens: '',
max_tokens: '',
messages: [],
metadata: '',
modalities: '',
model: '',
n: '',
parallel_tool_calls: '',
prediction: '',
presence_penalty: '',
reasoning_effort: '',
response_format: '',
seed: '',
service_tier: '',
stop: '',
store: '',
stream: '',
stream_options: '',
temperature: '',
tool_choice: '',
tools: '',
top_logprobs: '',
top_p: '',
user: '',
web_search_options: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/chat/completions',
headers: {'content-type': 'application/json'},
data: {
audio: '',
frequency_penalty: '',
function_call: '',
functions: '',
logit_bias: '',
logprobs: '',
max_completion_tokens: '',
max_tokens: '',
messages: [],
metadata: '',
modalities: '',
model: '',
n: '',
parallel_tool_calls: '',
prediction: '',
presence_penalty: '',
reasoning_effort: '',
response_format: '',
seed: '',
service_tier: '',
stop: '',
store: '',
stream: '',
stream_options: '',
temperature: '',
tool_choice: '',
tools: '',
top_logprobs: '',
top_p: '',
user: '',
web_search_options: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/chat/completions';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"audio":"","frequency_penalty":"","function_call":"","functions":"","logit_bias":"","logprobs":"","max_completion_tokens":"","max_tokens":"","messages":[],"metadata":"","modalities":"","model":"","n":"","parallel_tool_calls":"","prediction":"","presence_penalty":"","reasoning_effort":"","response_format":"","seed":"","service_tier":"","stop":"","store":"","stream":"","stream_options":"","temperature":"","tool_choice":"","tools":"","top_logprobs":"","top_p":"","user":"","web_search_options":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"audio": @"",
@"frequency_penalty": @"",
@"function_call": @"",
@"functions": @"",
@"logit_bias": @"",
@"logprobs": @"",
@"max_completion_tokens": @"",
@"max_tokens": @"",
@"messages": @[ ],
@"metadata": @"",
@"modalities": @"",
@"model": @"",
@"n": @"",
@"parallel_tool_calls": @"",
@"prediction": @"",
@"presence_penalty": @"",
@"reasoning_effort": @"",
@"response_format": @"",
@"seed": @"",
@"service_tier": @"",
@"stop": @"",
@"store": @"",
@"stream": @"",
@"stream_options": @"",
@"temperature": @"",
@"tool_choice": @"",
@"tools": @"",
@"top_logprobs": @"",
@"top_p": @"",
@"user": @"",
@"web_search_options": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/chat/completions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/chat/completions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/chat/completions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'audio' => '',
'frequency_penalty' => '',
'function_call' => '',
'functions' => '',
'logit_bias' => '',
'logprobs' => '',
'max_completion_tokens' => '',
'max_tokens' => '',
'messages' => [
],
'metadata' => '',
'modalities' => '',
'model' => '',
'n' => '',
'parallel_tool_calls' => '',
'prediction' => '',
'presence_penalty' => '',
'reasoning_effort' => '',
'response_format' => '',
'seed' => '',
'service_tier' => '',
'stop' => '',
'store' => '',
'stream' => '',
'stream_options' => '',
'temperature' => '',
'tool_choice' => '',
'tools' => '',
'top_logprobs' => '',
'top_p' => '',
'user' => '',
'web_search_options' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/chat/completions', [
'body' => '{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/chat/completions');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'audio' => '',
'frequency_penalty' => '',
'function_call' => '',
'functions' => '',
'logit_bias' => '',
'logprobs' => '',
'max_completion_tokens' => '',
'max_tokens' => '',
'messages' => [
],
'metadata' => '',
'modalities' => '',
'model' => '',
'n' => '',
'parallel_tool_calls' => '',
'prediction' => '',
'presence_penalty' => '',
'reasoning_effort' => '',
'response_format' => '',
'seed' => '',
'service_tier' => '',
'stop' => '',
'store' => '',
'stream' => '',
'stream_options' => '',
'temperature' => '',
'tool_choice' => '',
'tools' => '',
'top_logprobs' => '',
'top_p' => '',
'user' => '',
'web_search_options' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'audio' => '',
'frequency_penalty' => '',
'function_call' => '',
'functions' => '',
'logit_bias' => '',
'logprobs' => '',
'max_completion_tokens' => '',
'max_tokens' => '',
'messages' => [
],
'metadata' => '',
'modalities' => '',
'model' => '',
'n' => '',
'parallel_tool_calls' => '',
'prediction' => '',
'presence_penalty' => '',
'reasoning_effort' => '',
'response_format' => '',
'seed' => '',
'service_tier' => '',
'stop' => '',
'store' => '',
'stream' => '',
'stream_options' => '',
'temperature' => '',
'tool_choice' => '',
'tools' => '',
'top_logprobs' => '',
'top_p' => '',
'user' => '',
'web_search_options' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/chat/completions');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/chat/completions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/chat/completions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/chat/completions", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/chat/completions"
payload = {
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/chat/completions"
payload <- "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/chat/completions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/chat/completions') do |req|
req.body = "{\n \"audio\": \"\",\n \"frequency_penalty\": \"\",\n \"function_call\": \"\",\n \"functions\": \"\",\n \"logit_bias\": \"\",\n \"logprobs\": \"\",\n \"max_completion_tokens\": \"\",\n \"max_tokens\": \"\",\n \"messages\": [],\n \"metadata\": \"\",\n \"modalities\": \"\",\n \"model\": \"\",\n \"n\": \"\",\n \"parallel_tool_calls\": \"\",\n \"prediction\": \"\",\n \"presence_penalty\": \"\",\n \"reasoning_effort\": \"\",\n \"response_format\": \"\",\n \"seed\": \"\",\n \"service_tier\": \"\",\n \"stop\": \"\",\n \"store\": \"\",\n \"stream\": \"\",\n \"stream_options\": \"\",\n \"temperature\": \"\",\n \"tool_choice\": \"\",\n \"tools\": \"\",\n \"top_logprobs\": \"\",\n \"top_p\": \"\",\n \"user\": \"\",\n \"web_search_options\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/chat/completions";
let payload = json!({
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": (),
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/chat/completions \
--header 'content-type: application/json' \
--data '{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}'echo '{
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
}' | \
http POST {{baseUrl}}/v1/chat/completions \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "audio": "",\n "frequency_penalty": "",\n "function_call": "",\n "functions": "",\n "logit_bias": "",\n "logprobs": "",\n "max_completion_tokens": "",\n "max_tokens": "",\n "messages": [],\n "metadata": "",\n "modalities": "",\n "model": "",\n "n": "",\n "parallel_tool_calls": "",\n "prediction": "",\n "presence_penalty": "",\n "reasoning_effort": "",\n "response_format": "",\n "seed": "",\n "service_tier": "",\n "stop": "",\n "store": "",\n "stream": "",\n "stream_options": "",\n "temperature": "",\n "tool_choice": "",\n "tools": "",\n "top_logprobs": "",\n "top_p": "",\n "user": "",\n "web_search_options": ""\n}' \
--output-document \
- {{baseUrl}}/v1/chat/completionsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"audio": "",
"frequency_penalty": "",
"function_call": "",
"functions": "",
"logit_bias": "",
"logprobs": "",
"max_completion_tokens": "",
"max_tokens": "",
"messages": [],
"metadata": "",
"modalities": "",
"model": "",
"n": "",
"parallel_tool_calls": "",
"prediction": "",
"presence_penalty": "",
"reasoning_effort": "",
"response_format": "",
"seed": "",
"service_tier": "",
"stop": "",
"store": "",
"stream": "",
"stream_options": "",
"temperature": "",
"tool_choice": "",
"tools": "",
"top_logprobs": "",
"top_p": "",
"user": "",
"web_search_options": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/chat/completions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"id": "chatcmpl-123",
"object": "chat.completion",
"created": 1677652288,
"model": "gpt-4o-mini",
"system_fingerprint": "fp_44709d6fcb",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "\n\nHello there, how may I assist you today?"
},
"logprobs": null,
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 9,
"completion_tokens": 12,
"total_tokens": 21,
"completion_tokens_details": {
"reasoning_tokens": 0,
"accepted_prediction_tokens": 0,
"rejected_prediction_tokens": 0
}
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "An internal server error occurred while processing the chat completion."
}
POST
Create Embeddings
{{baseUrl}}/v1/embeddings
BODY json
{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/embeddings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/embeddings" {:content-type :json
:form-params {:dimensions ""
:encoding_format ""
:input ""
:model ""
:user ""}})require "http/client"
url = "{{baseUrl}}/v1/embeddings"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/embeddings"),
Content = new StringContent("{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/embeddings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/embeddings"
payload := strings.NewReader("{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/embeddings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91
{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/embeddings")
.setHeader("content-type", "application/json")
.setBody("{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/embeddings"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/embeddings")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/embeddings")
.header("content-type", "application/json")
.body("{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}")
.asString(); const data = JSON.stringify({
dimensions: '',
encoding_format: '',
input: '',
model: '',
user: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/embeddings');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/embeddings',
headers: {'content-type': 'application/json'},
data: {dimensions: '', encoding_format: '', input: '', model: '', user: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/embeddings';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dimensions":"","encoding_format":"","input":"","model":"","user":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/embeddings',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dimensions": "",\n "encoding_format": "",\n "input": "",\n "model": "",\n "user": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/embeddings")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/embeddings',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({dimensions: '', encoding_format: '', input: '', model: '', user: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/embeddings',
headers: {'content-type': 'application/json'},
body: {dimensions: '', encoding_format: '', input: '', model: '', user: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/embeddings');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dimensions: '',
encoding_format: '',
input: '',
model: '',
user: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/embeddings',
headers: {'content-type': 'application/json'},
data: {dimensions: '', encoding_format: '', input: '', model: '', user: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/embeddings';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dimensions":"","encoding_format":"","input":"","model":"","user":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dimensions": @"",
@"encoding_format": @"",
@"input": @"",
@"model": @"",
@"user": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/embeddings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/embeddings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/embeddings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'dimensions' => '',
'encoding_format' => '',
'input' => '',
'model' => '',
'user' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/embeddings', [
'body' => '{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/embeddings');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dimensions' => '',
'encoding_format' => '',
'input' => '',
'model' => '',
'user' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dimensions' => '',
'encoding_format' => '',
'input' => '',
'model' => '',
'user' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/embeddings');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/embeddings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/embeddings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/embeddings", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/embeddings"
payload = {
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/embeddings"
payload <- "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/embeddings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/embeddings') do |req|
req.body = "{\n \"dimensions\": \"\",\n \"encoding_format\": \"\",\n \"input\": \"\",\n \"model\": \"\",\n \"user\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/embeddings";
let payload = json!({
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/embeddings \
--header 'content-type: application/json' \
--data '{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}'echo '{
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
}' | \
http POST {{baseUrl}}/v1/embeddings \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "dimensions": "",\n "encoding_format": "",\n "input": "",\n "model": "",\n "user": ""\n}' \
--output-document \
- {{baseUrl}}/v1/embeddingsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dimensions": "",
"encoding_format": "",
"input": "",
"model": "",
"user": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/embeddings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"object": "list",
"data": [
{
"object": "embedding",
"embedding": [
0.0023064255,
-0.009327292,
-0.0028842222
],
"index": 0
}
],
"model": "text-embedding-ada-002",
"usage": {
"prompt_tokens": 8,
"total_tokens": 8
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "model not found"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "Unexpected internal server error occurred"
}
GET
List Models
{{baseUrl}}/v1/models
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/models");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/models")require "http/client"
url = "{{baseUrl}}/v1/models"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/models"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/models");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/models"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/models HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/models")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/models"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/models")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/models")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/models');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/models'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/models';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/models',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/models")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/models',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/models'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/models');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/models'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/models';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/models"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/models" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/models",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/models');
echo $response->getBody();setUrl('{{baseUrl}}/v1/models');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/models');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/models' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/models' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/models")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/models"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/models"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/models")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/models') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/models";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/modelshttp GET {{baseUrl}}/v1/modelswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/modelsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/models")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"object": "list",
"data": [
{
"id": "gpt-4",
"object": "model",
"owned_by": "openai",
"datasets": null,
"status": "ready"
},
{
"id": "text-embedding-ada-002",
"object": "model",
"owned_by": "openai-internal",
"datasets": [
"text-dataset-1",
"text-dataset-2"
],
"status": "ready"
}
]
}RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
id,object,owned_by,datasets,status
gpt-4,model,openai,,ready
text-embedding-ada-002,model,openai-internal,"text-dataset-1,text-dataset-2",ready
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "App not initialized"
}
GET
ML Prediction
{{baseUrl}}/v1/models/:name/predict
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/models/:name/predict");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/models/:name/predict")require "http/client"
url = "{{baseUrl}}/v1/models/:name/predict"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/models/:name/predict"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/models/:name/predict");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/models/:name/predict"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/models/:name/predict HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/models/:name/predict")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/models/:name/predict"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/models/:name/predict")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/models/:name/predict")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/models/:name/predict');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/models/:name/predict'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/models/:name/predict';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/models/:name/predict',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/models/:name/predict")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/models/:name/predict',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/models/:name/predict'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/models/:name/predict');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/models/:name/predict'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/models/:name/predict';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/models/:name/predict"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/models/:name/predict" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/models/:name/predict",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/models/:name/predict');
echo $response->getBody();setUrl('{{baseUrl}}/v1/models/:name/predict');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/models/:name/predict');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/models/:name/predict' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/models/:name/predict' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/models/:name/predict")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/models/:name/predict"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/models/:name/predict"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/models/:name/predict")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/models/:name/predict') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/models/:name/predict";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/models/:name/predicthttp GET {{baseUrl}}/v1/models/:name/predictwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/models/:name/predictimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/models/:name/predict")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"status": "Success",
"model_name": "my_model_name",
"model_version": "1.0",
"prediction": [
0.45,
0.5,
0.55
],
"duration_ms": 123
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"status": "BadRequest",
"error_message": "You gave me a bad request :(",
"model_name": "my_model_name",
"duration_ms": 12
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"status": "InternalError",
"error_message": "Oops, the server couldn't predict",
"model_name": "my_model_name",
"duration_ms": 12
}
GET
List Catalogs
{{baseUrl}}/v1/catalogs
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/catalogs");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/catalogs")require "http/client"
url = "{{baseUrl}}/v1/catalogs"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/catalogs"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/catalogs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/catalogs"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/catalogs HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/catalogs")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/catalogs"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/catalogs")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/catalogs")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/catalogs');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/catalogs'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/catalogs';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/catalogs',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/catalogs")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/catalogs',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/catalogs'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/catalogs');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/catalogs'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/catalogs';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/catalogs"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/catalogs" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/catalogs",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/catalogs');
echo $response->getBody();setUrl('{{baseUrl}}/v1/catalogs');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/catalogs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/catalogs' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/catalogs' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/catalogs")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/catalogs"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/catalogs"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/catalogs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/catalogs') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/catalogs";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/catalogshttp GET {{baseUrl}}/v1/catalogswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/catalogsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/catalogs")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"from": "spiceai",
"name": "spiceai"
}
]RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
from,name
spiceai,spiceai
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "An unexpected error occurred while processing the catalogs"
}
GET
List Datasets
{{baseUrl}}/v1/datasets
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/datasets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/datasets")require "http/client"
url = "{{baseUrl}}/v1/datasets"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/datasets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/datasets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/datasets"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/datasets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/datasets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/datasets"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/datasets")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/datasets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/datasets');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/datasets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/datasets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/datasets',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/datasets")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/datasets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/datasets'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/datasets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/datasets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/datasets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/datasets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/datasets" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/datasets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/datasets');
echo $response->getBody();setUrl('{{baseUrl}}/v1/datasets');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/datasets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/datasets' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/datasets' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/datasets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/datasets"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/datasets"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/datasets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/datasets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/datasets";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/datasetshttp GET {{baseUrl}}/v1/datasetswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/datasetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/datasets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"from": "postgres:syncs",
"name": "daily_journal_accelerated",
"replication_enabled": false,
"acceleration_enabled": true
},
{
"from": "databricks:hive_metastore.default.messages",
"name": "messages_accelerated",
"replication_enabled": false,
"acceleration_enabled": true
},
{
"from": "postgres:aidemo_messages",
"name": "general",
"replication_enabled": false,
"acceleration_enabled": false
}
]RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
from,name,replication_enabled,acceleration_enabled
postgres:syncs,daily_journal_accelerated,false,true
databricks:hive_metastore.default.messages,messages_accelerated,false,true
postgres:aidemo_messages,general,false,false
RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
An unexpected error occurred while processing datasets
POST
Refresh Dataset
{{baseUrl}}/v1/datasets/:name/acceleration/refresh
QUERY PARAMS
name
BODY json
{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/datasets/:name/acceleration/refresh");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/datasets/:name/acceleration/refresh" {:content-type :json
:form-params {:refresh_jitter_max ""
:refresh_mode ""
:refresh_sql ""}})require "http/client"
url = "{{baseUrl}}/v1/datasets/:name/acceleration/refresh"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/datasets/:name/acceleration/refresh"),
Content = new StringContent("{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/datasets/:name/acceleration/refresh");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/datasets/:name/acceleration/refresh"
payload := strings.NewReader("{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/datasets/:name/acceleration/refresh HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 73
{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/datasets/:name/acceleration/refresh")
.setHeader("content-type", "application/json")
.setBody("{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/datasets/:name/acceleration/refresh"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/datasets/:name/acceleration/refresh")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/datasets/:name/acceleration/refresh")
.header("content-type", "application/json")
.body("{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}")
.asString(); const data = JSON.stringify({
refresh_jitter_max: '',
refresh_mode: '',
refresh_sql: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/datasets/:name/acceleration/refresh');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/datasets/:name/acceleration/refresh',
headers: {'content-type': 'application/json'},
data: {refresh_jitter_max: '', refresh_mode: '', refresh_sql: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/datasets/:name/acceleration/refresh';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"refresh_jitter_max":"","refresh_mode":"","refresh_sql":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/datasets/:name/acceleration/refresh',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "refresh_jitter_max": "",\n "refresh_mode": "",\n "refresh_sql": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/datasets/:name/acceleration/refresh")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/datasets/:name/acceleration/refresh',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({refresh_jitter_max: '', refresh_mode: '', refresh_sql: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/datasets/:name/acceleration/refresh',
headers: {'content-type': 'application/json'},
body: {refresh_jitter_max: '', refresh_mode: '', refresh_sql: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/datasets/:name/acceleration/refresh');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
refresh_jitter_max: '',
refresh_mode: '',
refresh_sql: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/datasets/:name/acceleration/refresh',
headers: {'content-type': 'application/json'},
data: {refresh_jitter_max: '', refresh_mode: '', refresh_sql: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/datasets/:name/acceleration/refresh';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"refresh_jitter_max":"","refresh_mode":"","refresh_sql":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"refresh_jitter_max": @"",
@"refresh_mode": @"",
@"refresh_sql": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/datasets/:name/acceleration/refresh"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/datasets/:name/acceleration/refresh" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/datasets/:name/acceleration/refresh",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'refresh_jitter_max' => '',
'refresh_mode' => '',
'refresh_sql' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/datasets/:name/acceleration/refresh', [
'body' => '{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/datasets/:name/acceleration/refresh');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'refresh_jitter_max' => '',
'refresh_mode' => '',
'refresh_sql' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'refresh_jitter_max' => '',
'refresh_mode' => '',
'refresh_sql' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/datasets/:name/acceleration/refresh');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/datasets/:name/acceleration/refresh' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/datasets/:name/acceleration/refresh' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/datasets/:name/acceleration/refresh", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/datasets/:name/acceleration/refresh"
payload = {
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/datasets/:name/acceleration/refresh"
payload <- "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/datasets/:name/acceleration/refresh")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/datasets/:name/acceleration/refresh') do |req|
req.body = "{\n \"refresh_jitter_max\": \"\",\n \"refresh_mode\": \"\",\n \"refresh_sql\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/datasets/:name/acceleration/refresh";
let payload = json!({
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/datasets/:name/acceleration/refresh \
--header 'content-type: application/json' \
--data '{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}'echo '{
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
}' | \
http POST {{baseUrl}}/v1/datasets/:name/acceleration/refresh \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "refresh_jitter_max": "",\n "refresh_mode": "",\n "refresh_sql": ""\n}' \
--output-document \
- {{baseUrl}}/v1/datasets/:name/acceleration/refreshimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"refresh_jitter_max": "",
"refresh_mode": "",
"refresh_sql": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/datasets/:name/acceleration/refresh")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Dataset refresh triggered for taxi_trips."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Dataset taxi_trips does not have acceleration enabled"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Dataset taxi_trips not found"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Unexpected internal error occurred while processing refresh"
}
PATCH
Update Refresh SQL
{{baseUrl}}/v1/datasets/:name/acceleration
QUERY PARAMS
name
BODY json
{
"refresh_sql": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/datasets/:name/acceleration");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"refresh_sql\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/v1/datasets/:name/acceleration" {:content-type :json
:form-params {:refresh_sql ""}})require "http/client"
url = "{{baseUrl}}/v1/datasets/:name/acceleration"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"refresh_sql\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/v1/datasets/:name/acceleration"),
Content = new StringContent("{\n \"refresh_sql\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/datasets/:name/acceleration");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"refresh_sql\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/datasets/:name/acceleration"
payload := strings.NewReader("{\n \"refresh_sql\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/v1/datasets/:name/acceleration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23
{
"refresh_sql": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1/datasets/:name/acceleration")
.setHeader("content-type", "application/json")
.setBody("{\n \"refresh_sql\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/datasets/:name/acceleration"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"refresh_sql\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"refresh_sql\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/datasets/:name/acceleration")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/v1/datasets/:name/acceleration")
.header("content-type", "application/json")
.body("{\n \"refresh_sql\": \"\"\n}")
.asString(); const data = JSON.stringify({
refresh_sql: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/v1/datasets/:name/acceleration');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/datasets/:name/acceleration',
headers: {'content-type': 'application/json'},
data: {refresh_sql: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/datasets/:name/acceleration';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"refresh_sql":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/datasets/:name/acceleration',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "refresh_sql": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"refresh_sql\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/datasets/:name/acceleration")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/datasets/:name/acceleration',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({refresh_sql: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/datasets/:name/acceleration',
headers: {'content-type': 'application/json'},
body: {refresh_sql: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/v1/datasets/:name/acceleration');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
refresh_sql: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/v1/datasets/:name/acceleration',
headers: {'content-type': 'application/json'},
data: {refresh_sql: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/datasets/:name/acceleration';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"refresh_sql":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"refresh_sql": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/datasets/:name/acceleration"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/datasets/:name/acceleration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"refresh_sql\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/datasets/:name/acceleration",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'refresh_sql' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/v1/datasets/:name/acceleration', [
'body' => '{
"refresh_sql": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/datasets/:name/acceleration');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'refresh_sql' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'refresh_sql' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/datasets/:name/acceleration');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/datasets/:name/acceleration' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"refresh_sql": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/datasets/:name/acceleration' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"refresh_sql": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"refresh_sql\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/v1/datasets/:name/acceleration", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/datasets/:name/acceleration"
payload = { "refresh_sql": "" }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/datasets/:name/acceleration"
payload <- "{\n \"refresh_sql\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/datasets/:name/acceleration")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"refresh_sql\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/v1/datasets/:name/acceleration') do |req|
req.body = "{\n \"refresh_sql\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/datasets/:name/acceleration";
let payload = json!({"refresh_sql": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/v1/datasets/:name/acceleration \
--header 'content-type: application/json' \
--data '{
"refresh_sql": ""
}'echo '{
"refresh_sql": ""
}' | \
http PATCH {{baseUrl}}/v1/datasets/:name/acceleration \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "refresh_sql": ""\n}' \
--output-document \
- {{baseUrl}}/v1/datasets/:name/accelerationimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["refresh_sql": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/datasets/:name/acceleration")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Dataset eth_recent_blocks not found"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Request failed. An internal server error occurred while updating refresh SQL."
}
GET
List Evals
{{baseUrl}}/v1/evals
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/evals");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/evals")require "http/client"
url = "{{baseUrl}}/v1/evals"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/evals"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/evals");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/evals"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/evals HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/evals")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/evals"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/evals")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/evals")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/evals');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/evals'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/evals';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/evals',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/evals")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/evals',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/evals'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/evals');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/evals'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/evals';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/evals"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/evals" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/evals",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/evals');
echo $response->getBody();setUrl('{{baseUrl}}/v1/evals');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/evals');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/evals' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/evals' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/evals")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/evals"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/evals"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/evals")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/evals') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/evals";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/evalshttp GET {{baseUrl}}/v1/evalswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/evalsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/evals")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"name": "knows_math",
"description": "Questions from first year, undergraduate math exams",
"dataset": "math_exams",
"scorers": [
"match",
"professor_logical_consistency"
]
}
]
POST
Run Eval
{{baseUrl}}/v1/evals/:name
QUERY PARAMS
name
BODY json
{
"model": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/evals/:name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"model\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/evals/:name" {:content-type :json
:form-params {:model ""}})require "http/client"
url = "{{baseUrl}}/v1/evals/:name"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"model\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/evals/:name"),
Content = new StringContent("{\n \"model\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/evals/:name");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"model\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/evals/:name"
payload := strings.NewReader("{\n \"model\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/evals/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17
{
"model": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/evals/:name")
.setHeader("content-type", "application/json")
.setBody("{\n \"model\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/evals/:name"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"model\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"model\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/evals/:name")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/evals/:name")
.header("content-type", "application/json")
.body("{\n \"model\": \"\"\n}")
.asString(); const data = JSON.stringify({
model: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/evals/:name');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/evals/:name',
headers: {'content-type': 'application/json'},
data: {model: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/evals/:name';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"model":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/evals/:name',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "model": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"model\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/evals/:name")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/evals/:name',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({model: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/evals/:name',
headers: {'content-type': 'application/json'},
body: {model: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/evals/:name');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
model: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/evals/:name',
headers: {'content-type': 'application/json'},
data: {model: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/evals/:name';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"model":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"model": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/evals/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/evals/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"model\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/evals/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'model' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/evals/:name', [
'body' => '{
"model": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/evals/:name');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'model' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'model' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/evals/:name');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/evals/:name' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"model": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/evals/:name' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"model": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"model\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/evals/:name", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/evals/:name"
payload = { "model": "" }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/evals/:name"
payload <- "{\n \"model\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/evals/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"model\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/evals/:name') do |req|
req.body = "{\n \"model\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/evals/:name";
let payload = json!({"model": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/evals/:name \
--header 'content-type: application/json' \
--data '{
"model": ""
}'echo '{
"model": ""
}' | \
http POST {{baseUrl}}/v1/evals/:name \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "model": ""\n}' \
--output-document \
- {{baseUrl}}/v1/evals/:nameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["model": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/evals/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"primary_key": "eval_12345",
"time_column": "2024-12-19T12:34:56Z",
"dataset": "my_dataset",
"model": "example_model",
"status": "completed",
"error_message": null,
"scorers": [
"scorer1",
"scorer2"
],
"metrics": {
"scorer1/accuracy": 0.95,
"scorer2/accuracy": 0.93
}
}RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
primary_key,time_column,dataset,model,status,error_message,scorers,metrics
eval_12345,2024-12-19T12:34:56Z,my_dataset,example_model,completed,,"[""scorer1"", ""scorer2""]","{""scorer1/accuracy"":0.95, ""scorer2/accuracy"":0.93}"RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
+-------------+---------------------+-----------+---------------+-----------+----------------+------------------+---------------------------------------+
| primary_key | time_column | dataset | model | status | error_message | scorers | metrics |
+-------------+---------------------+-----------+---------------+-----------+----------------+------------------+---------------------------------------+
| eval_12345 | 2024-12-19T12:34:56Z| my_dataset| example_model | completed | | scorer1, scorer2 | {"accuracy": 0.95, "precision": 0.93} |
+-------------+---------------------+-----------+---------------+-----------+----------------+------------------+---------------------------------------+
GET
Check Runtime Status
{{baseUrl}}/v1/status
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/status");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/status")require "http/client"
url = "{{baseUrl}}/v1/status"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/status"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/status"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/status HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/status")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/status"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/status")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/status")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/status');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/status'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/status';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/status',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/status")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/status',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/status'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/status');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/status'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/status';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/status"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/status" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/status",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/status');
echo $response->getBody();setUrl('{{baseUrl}}/v1/status');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/status' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/status' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/status")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/status"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/status"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/status")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/status') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/status";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/statushttp GET {{baseUrl}}/v1/statuswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/statusimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/status")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"name": "http",
"endpoint": "http://127.0.0.1:8080",
"status": "Ready"
},
{
"name": "flight",
"endpoint": "http://127.0.0.1:9000",
"status": "Initializing"
},
{
"name": "metrics",
"endpoint": "N/A",
"status": "Disabled"
},
{
"name": "opentelemetry",
"endpoint": "http://127.0.0.1:4317",
"status": "Error"
}
]RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
name,endpoint,status
http,http://127.0.0.1:8080,Ready
flight,http://127.0.0.1:9000,Initializing
metrics,N/A,Disabled
opentelemetry,http://127.0.0.1:4317,ErrorRESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
Error converting to CSV
POST
Generate Package
{{baseUrl}}/v1/packages/generate
BODY json
{
"from": "",
"params": {}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/packages/generate");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"from\": \"\",\n \"params\": {}\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/packages/generate" {:content-type :json
:form-params {:from ""
:params {}}})require "http/client"
url = "{{baseUrl}}/v1/packages/generate"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"from\": \"\",\n \"params\": {}\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/packages/generate"),
Content = new StringContent("{\n \"from\": \"\",\n \"params\": {}\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/packages/generate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"from\": \"\",\n \"params\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/packages/generate"
payload := strings.NewReader("{\n \"from\": \"\",\n \"params\": {}\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/packages/generate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32
{
"from": "",
"params": {}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/packages/generate")
.setHeader("content-type", "application/json")
.setBody("{\n \"from\": \"\",\n \"params\": {}\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/packages/generate"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"from\": \"\",\n \"params\": {}\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"from\": \"\",\n \"params\": {}\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/packages/generate")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/packages/generate")
.header("content-type", "application/json")
.body("{\n \"from\": \"\",\n \"params\": {}\n}")
.asString(); const data = JSON.stringify({
from: '',
params: {}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/packages/generate');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/packages/generate',
headers: {'content-type': 'application/json'},
data: {from: '', params: {}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/packages/generate';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"from":"","params":{}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/packages/generate',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "from": "",\n "params": {}\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"from\": \"\",\n \"params\": {}\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/packages/generate")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/packages/generate',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({from: '', params: {}}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/packages/generate',
headers: {'content-type': 'application/json'},
body: {from: '', params: {}},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/packages/generate');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
from: '',
params: {}
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/packages/generate',
headers: {'content-type': 'application/json'},
data: {from: '', params: {}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/packages/generate';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"from":"","params":{}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"from": @"",
@"params": @{ } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/packages/generate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/packages/generate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"from\": \"\",\n \"params\": {}\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/packages/generate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'from' => '',
'params' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/packages/generate', [
'body' => '{
"from": "",
"params": {}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/packages/generate');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'from' => '',
'params' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'from' => '',
'params' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/v1/packages/generate');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/packages/generate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"from": "",
"params": {}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/packages/generate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"from": "",
"params": {}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"from\": \"\",\n \"params\": {}\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/v1/packages/generate", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/packages/generate"
payload = {
"from": "",
"params": {}
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/packages/generate"
payload <- "{\n \"from\": \"\",\n \"params\": {}\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/packages/generate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"from\": \"\",\n \"params\": {}\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/packages/generate') do |req|
req.body = "{\n \"from\": \"\",\n \"params\": {}\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/packages/generate";
let payload = json!({
"from": "",
"params": json!({})
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/packages/generate \
--header 'content-type: application/json' \
--data '{
"from": "",
"params": {}
}'echo '{
"from": "",
"params": {}
}' | \
http POST {{baseUrl}}/v1/packages/generate \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "from": "",\n "params": {}\n}' \
--output-document \
- {{baseUrl}}/v1/packages/generateimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"from": "",
"params": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/packages/generate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/zip
RESPONSE BODY text
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "Invalid `from` field, specify a github source and retry (e.g. github:{org}/{repo}/{sha}/{path_to_spicepod.yaml})"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "An unexpected error occurred"
}
GET
List Spicepods
{{baseUrl}}/v1/spicepods
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/spicepods");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/spicepods")require "http/client"
url = "{{baseUrl}}/v1/spicepods"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/spicepods"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/spicepods");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/spicepods"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/spicepods HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/spicepods")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/spicepods"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/spicepods")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/spicepods")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/spicepods');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/spicepods'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/spicepods';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/spicepods',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/spicepods")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/spicepods',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/spicepods'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/spicepods');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/spicepods'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/spicepods';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/spicepods"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/spicepods" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/spicepods",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/spicepods');
echo $response->getBody();setUrl('{{baseUrl}}/v1/spicepods');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/spicepods');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/spicepods' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/spicepods' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/spicepods")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/spicepods"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/spicepods"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/spicepods")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/spicepods') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/spicepods";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/spicepodshttp GET {{baseUrl}}/v1/spicepodswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/spicepodsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/spicepods")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"name": "spicepod1",
"version": "v1.0.0",
"datasets_count": 3,
"models_count": 2,
"dependencies_count": 5
},
{
"name": "spicepod2",
"version": "v2.0.0",
"datasets_count": 4,
"models_count": 3,
"dependencies_count": 2
}
]RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
name,version,datasets_count,models_count,dependencies_count
spicepod1,v1.0.0,3,2,5
spicepod2,v2.0.0,4,3,2RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
Internal server error
HEAD
Check Namespace exists
{{baseUrl}}/v1/iceberg/namespaces/:namespace
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "HEAD");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/iceberg/namespaces/:namespace");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/head "{{baseUrl}}/v1/iceberg/namespaces/:namespace")require "http/client"
url = "{{baseUrl}}/v1/iceberg/namespaces/:namespace"
response = HTTP::Client.head url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Head,
RequestUri = new Uri("{{baseUrl}}/v1/iceberg/namespaces/:namespace"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/iceberg/namespaces/:namespace");
var request = new RestRequest("", Method.Head);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/iceberg/namespaces/:namespace"
req, _ := http.NewRequest("HEAD", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}HEAD /baseUrl/v1/iceberg/namespaces/:namespace HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("HEAD", "{{baseUrl}}/v1/iceberg/namespaces/:namespace")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/iceberg/namespaces/:namespace"))
.method("HEAD", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/iceberg/namespaces/:namespace")
.head()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.head("{{baseUrl}}/v1/iceberg/namespaces/:namespace")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('HEAD', '{{baseUrl}}/v1/iceberg/namespaces/:namespace');
xhr.send(data);import axios from 'axios';
const options = {
method: 'HEAD',
url: '{{baseUrl}}/v1/iceberg/namespaces/:namespace'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/iceberg/namespaces/:namespace';
const options = {method: 'HEAD'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/iceberg/namespaces/:namespace',
method: 'HEAD',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/iceberg/namespaces/:namespace")
.head()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'HEAD',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/iceberg/namespaces/:namespace',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'HEAD',
url: '{{baseUrl}}/v1/iceberg/namespaces/:namespace'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('HEAD', '{{baseUrl}}/v1/iceberg/namespaces/:namespace');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'HEAD',
url: '{{baseUrl}}/v1/iceberg/namespaces/:namespace'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/iceberg/namespaces/:namespace';
const options = {method: 'HEAD'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/iceberg/namespaces/:namespace"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"HEAD"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/iceberg/namespaces/:namespace" in
Client.call `HEAD uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/iceberg/namespaces/:namespace",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "HEAD",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('HEAD', '{{baseUrl}}/v1/iceberg/namespaces/:namespace');
echo $response->getBody();setUrl('{{baseUrl}}/v1/iceberg/namespaces/:namespace');
$request->setMethod(HTTP_METH_HEAD);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/iceberg/namespaces/:namespace');
$request->setRequestMethod('HEAD');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/iceberg/namespaces/:namespace' -Method HEAD $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/iceberg/namespaces/:namespace' -Method HEAD import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("HEAD", "/baseUrl/v1/iceberg/namespaces/:namespace")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/iceberg/namespaces/:namespace"
response = requests.head(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/iceberg/namespaces/:namespace"
response <- VERB("HEAD", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/iceberg/namespaces/:namespace")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Head.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.head('/baseUrl/v1/iceberg/namespaces/:namespace') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/iceberg/namespaces/:namespace";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("HEAD").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request HEAD \
--url {{baseUrl}}/v1/iceberg/namespaces/:namespacehttp HEAD {{baseUrl}}/v1/iceberg/namespaces/:namespacewget --quiet \
--method HEAD \
--output-document \
- {{baseUrl}}/v1/iceberg/namespaces/:namespaceimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/iceberg/namespaces/:namespace")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "HEAD"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get Iceberg API config
{{baseUrl}}/v1/iceberg/config
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/iceberg/config");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/iceberg/config")require "http/client"
url = "{{baseUrl}}/v1/iceberg/config"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/iceberg/config"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/iceberg/config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/iceberg/config"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/iceberg/config HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/iceberg/config")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/iceberg/config"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/iceberg/config")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/iceberg/config")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/iceberg/config');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/iceberg/config'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/iceberg/config';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/iceberg/config',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/iceberg/config")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/iceberg/config',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/iceberg/config'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/iceberg/config');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/iceberg/config'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/iceberg/config';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/iceberg/config"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/iceberg/config" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/iceberg/config",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/iceberg/config');
echo $response->getBody();setUrl('{{baseUrl}}/v1/iceberg/config');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/iceberg/config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/iceberg/config' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/iceberg/config' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/iceberg/config")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/iceberg/config"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/iceberg/config"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/iceberg/config")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/iceberg/config') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/iceberg/config";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/iceberg/confighttp GET {{baseUrl}}/v1/iceberg/configwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/iceberg/configimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/iceberg/config")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"overrides": {},
"defaults": {},
"endpoints": [
"GET /v1/iceberg/namespaces",
"HEAD /v1/iceberg/namespaces/{namespace}",
"GET /v1/iceberg/namespaces/{namespace}/tables",
"HEAD /v1/iceberg/namespaces/{namespace}/tables/{table}",
"GET /v1/iceberg/namespaces/{namespace}/tables/{table}"
]
}
GET
List Iceberg namespaces
{{baseUrl}}/v1/iceberg/namespaces
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/iceberg/namespaces");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/iceberg/namespaces")require "http/client"
url = "{{baseUrl}}/v1/iceberg/namespaces"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/iceberg/namespaces"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/iceberg/namespaces");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/iceberg/namespaces"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/iceberg/namespaces HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/iceberg/namespaces")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/iceberg/namespaces"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/iceberg/namespaces")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/iceberg/namespaces")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/iceberg/namespaces');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/iceberg/namespaces'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/iceberg/namespaces';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/iceberg/namespaces',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/iceberg/namespaces")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/iceberg/namespaces',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/iceberg/namespaces'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/iceberg/namespaces');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/iceberg/namespaces'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/iceberg/namespaces';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/iceberg/namespaces"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/iceberg/namespaces" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/iceberg/namespaces",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/iceberg/namespaces');
echo $response->getBody();setUrl('{{baseUrl}}/v1/iceberg/namespaces');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/iceberg/namespaces');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/iceberg/namespaces' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/iceberg/namespaces' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/iceberg/namespaces")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/iceberg/namespaces"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/iceberg/namespaces"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/iceberg/namespaces")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/iceberg/namespaces') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/iceberg/namespaces";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/iceberg/namespaceshttp GET {{baseUrl}}/v1/iceberg/namespaceswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/iceberg/namespacesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/iceberg/namespaces")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"namespaces": [
{
"parts": [
"catalog_a"
]
},
{
"parts": [
"catalog_b",
"schema_1"
]
}
]
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": {
"message": "Invalid namespace request",
"type": "BadRequestException",
"code": 400
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": {
"message": "Namespace provided does not exist",
"type": "NoSuchNamespaceException",
"code": 404
}
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": {
"message": "Internal Server Error: DF_SCHEMA_NOT_FOUND",
"type": "InternalServerError",
"code": 500
}
}
GET
Establish an MCP SSE Connection
{{baseUrl}}/v1/mcp/sse
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/mcp/sse");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/mcp/sse")require "http/client"
url = "{{baseUrl}}/v1/mcp/sse"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/mcp/sse"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/mcp/sse");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/mcp/sse"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/mcp/sse HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/mcp/sse")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/mcp/sse"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/mcp/sse")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/mcp/sse")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/mcp/sse');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/mcp/sse'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/mcp/sse';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/mcp/sse',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/mcp/sse")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/mcp/sse',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/mcp/sse'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/mcp/sse');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/mcp/sse'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/mcp/sse';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/mcp/sse"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/mcp/sse" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/mcp/sse",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/mcp/sse');
echo $response->getBody();setUrl('{{baseUrl}}/v1/mcp/sse');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/mcp/sse');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/mcp/sse' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/mcp/sse' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/mcp/sse")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/mcp/sse"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/mcp/sse"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/mcp/sse")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/mcp/sse') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/mcp/sse";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/mcp/ssehttp GET {{baseUrl}}/v1/mcp/ssewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/mcp/sseimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/mcp/sse")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Send message to MCP server
{{baseUrl}}/v1/mcp/sse
QUERY PARAMS
sessionId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/mcp/sse?sessionId=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/mcp/sse" {:query-params {:sessionId ""}})require "http/client"
url = "{{baseUrl}}/v1/mcp/sse?sessionId="
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/mcp/sse?sessionId="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/mcp/sse?sessionId=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/mcp/sse?sessionId="
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/mcp/sse?sessionId= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/mcp/sse?sessionId=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/mcp/sse?sessionId="))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/mcp/sse?sessionId=")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/mcp/sse?sessionId=")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/mcp/sse?sessionId=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/mcp/sse',
params: {sessionId: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/mcp/sse?sessionId=';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/mcp/sse?sessionId=',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/mcp/sse?sessionId=")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/mcp/sse?sessionId=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/mcp/sse',
qs: {sessionId: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/mcp/sse');
req.query({
sessionId: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/mcp/sse',
params: {sessionId: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/mcp/sse?sessionId=';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/mcp/sse?sessionId="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/mcp/sse?sessionId=" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/mcp/sse?sessionId=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/mcp/sse?sessionId=');
echo $response->getBody();setUrl('{{baseUrl}}/v1/mcp/sse');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'sessionId' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/mcp/sse');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'sessionId' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/mcp/sse?sessionId=' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/mcp/sse?sessionId=' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/v1/mcp/sse?sessionId=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/mcp/sse"
querystring = {"sessionId":""}
response = requests.post(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/mcp/sse"
queryString <- list(sessionId = "")
response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/mcp/sse?sessionId=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/mcp/sse') do |req|
req.params['sessionId'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/mcp/sse";
let querystring = [
("sessionId", ""),
];
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/v1/mcp/sse?sessionId='http POST '{{baseUrl}}/v1/mcp/sse?sessionId='wget --quiet \
--method POST \
--output-document \
- '{{baseUrl}}/v1/mcp/sse?sessionId='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/mcp/sse?sessionId=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Check Readiness
{{baseUrl}}/v1/ready
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/ready");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/ready")require "http/client"
url = "{{baseUrl}}/v1/ready"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/ready"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/ready");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/ready"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/ready HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/ready")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/ready"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/ready")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/ready")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/ready');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/ready'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/ready';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/ready',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/ready")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/ready',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/ready'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/ready');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/ready'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/ready';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/ready"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/ready" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/ready",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/ready');
echo $response->getBody();setUrl('{{baseUrl}}/v1/ready');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/ready');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/ready' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/ready' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/ready")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/ready"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/ready"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/ready")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/ready') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/ready";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/readyhttp GET {{baseUrl}}/v1/readywget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/readyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/ready")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
readyRESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
not ready
POST
SQL Query
{{baseUrl}}/v1/sql
HEADERS
Accept
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/sql");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/sql" {:headers {:accept ""}})require "http/client"
url = "{{baseUrl}}/v1/sql"
headers = HTTP::Headers{
"accept" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/sql"),
Headers =
{
{ "accept", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/sql");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/sql"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("accept", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/sql HTTP/1.1
Accept:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/sql")
.setHeader("accept", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/sql"))
.header("accept", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/sql")
.post(null)
.addHeader("accept", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/sql")
.header("accept", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/sql');
xhr.setRequestHeader('accept', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/sql',
headers: {accept: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/sql';
const options = {method: 'POST', headers: {accept: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/sql',
method: 'POST',
headers: {
accept: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/sql")
.post(null)
.addHeader("accept", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/sql',
headers: {
accept: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/sql',
headers: {accept: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/sql');
req.headers({
accept: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/sql',
headers: {accept: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/sql';
const options = {method: 'POST', headers: {accept: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"accept": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/sql"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/sql" in
let headers = Header.add (Header.init ()) "accept" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/sql",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "",
CURLOPT_HTTPHEADER => [
"accept: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/sql', [
'headers' => [
'accept' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/sql');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'accept' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/sql');
$request->setRequestMethod('POST');
$request->setHeaders([
'accept' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/sql' -Method POST -Headers $headers$headers=@{}
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/sql' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
payload = ""
headers = { 'accept': "" }
conn.request("POST", "/baseUrl/v1/sql", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/sql"
payload = ""
headers = {"accept": ""}
response = requests.post(url, data=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/sql"
payload <- ""
response <- VERB("POST", url, body = payload, content_type(""))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/sql")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["accept"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/sql') do |req|
req.headers['accept'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/sql";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("accept", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/sql \
--header 'accept: 'http POST {{baseUrl}}/v1/sql \
accept:''wget --quiet \
--method POST \
--header 'accept: ' \
--output-document \
- {{baseUrl}}/v1/sqlimport Foundation
let headers = ["accept": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/sql")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"AVG(my_table.tip_amount)": 3.072259971396793,
"AVG(my_table.total_amount)": 25.327816939456525,
"COUNT(Int64(1))": 31465,
"passenger_count": 0
},
{
"AVG(my_table.tip_amount)": 3.3712622884680057,
"AVG(my_table.total_amount)": 26.205230445474996,
"COUNT(Int64(1))": 2188739,
"passenger_count": 1
},
{
"AVG(my_table.tip_amount)": 3.7171302113290854,
"AVG(my_table.total_amount)": 29.520659930930304,
"COUNT(Int64(1))": 405103,
"passenger_count": 2
}
]RESPONSE HEADERS
Content-Type
text/csv
RESPONSE BODY text
"AVG(my_table.tip_amount)","AVG(my_table.total_amount)","COUNT(Int64(1))","passenger_count"
3.072259971396793,25.327816939456525,31465,0
3.3712622884680057,26.205230445474996,2188739,1
3.7171302113290854,29.520659930930304,405103,2RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
+----------------------------+----------------------------+----------------+---------------------+
| "AVG(my_table.tip_amount)" | "AVG(my_table.total_amount)" | "COUNT(Int64(1))" | "passenger_count" |
+----------------------------+----------------------------+----------------+---------------------+
| 3.072259971396793 | 25.327816939456525 | 31465 | 0 |
+----------------------------+----------------------------+----------------+---------------------+
| 3.3712622884680057 | 26.205230445474996 | 2188739 | 1 |
+----------------------------+----------------------------+----------------+---------------------+
| 3.7171302113290854 | 29.520659930930304 | 405103 | 2 |
+----------------------------+----------------------------+----------------+---------------------+RESPONSE HEADERS
Content-Type
application/vnd.spiceai.sql.v1+json
RESPONSE BODY text
{
"row_count": 3,
"schema": {
"fields": [
{
"name": "AVG(my_table.tip_amount)",
"data_type": "Float64",
"nullable": false,
"dict_id": 0,
"dict_is_ordered": false
},
{
"name": "AVG(my_table.total_amount)",
"data_type": "Float64",
"nullable": false,
"dict_id": 0,
"dict_is_ordered": false
},
{
"name": "COUNT(Int64(1))",
"data_type": "Int64",
"nullable": false,
"dict_id": 0,
"dict_is_ordered": false
},
{
"name": "passenger_count",
"data_type": "Int64",
"nullable": false,
"dict_id": 0,
"dict_is_ordered": false
}
]
},
"data": [
{
"AVG(my_table.tip_amount)": 3.072259971396793,
"AVG(my_table.total_amount)": 25.327816939456525,
"COUNT(Int64(1))": 31465,
"passenger_count": 0
},
{
"AVG(my_table.tip_amount)": 3.3712622884680057,
"AVG(my_table.total_amount)": 26.205230445474996,
"COUNT(Int64(1))": 2188739,
"passenger_count": 1
},
{
"AVG(my_table.tip_amount)": 3.7171302113290854,
"AVG(my_table.total_amount)": 29.520659930930304,
"COUNT(Int64(1))": 405103,
"passenger_count": 2
}
]
}RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
Error reading query: invalid UTF-8 sequenceRESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
Unexpected internal server error occurred
POST
Search
{{baseUrl}}/v1/search
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/search");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/search")require "http/client"
url = "{{baseUrl}}/v1/search"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/search"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/search");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/search"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/search HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/search")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/search"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/search")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/search")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/search');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/v1/search'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/search';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/search',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/search")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/search',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/v1/search'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/search');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/v1/search'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/search';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/search"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/search" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/search",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/search');
echo $response->getBody();setUrl('{{baseUrl}}/v1/search');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/search');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/search' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/search' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
payload = ""
conn.request("POST", "/baseUrl/v1/search", payload)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/search"
payload = ""
response = requests.post(url, data=payload)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/search"
payload <- ""
response <- VERB("POST", url, body = payload, content_type(""))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/search")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/search') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/search";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/searchhttp POST {{baseUrl}}/v1/searchwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/searchimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/search")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"results": [
{
"matches": {
"message": "I booked use some tickets"
},
"dataset": "app_messages",
"primary_key": {
"id": "6fd5a215-0881-421d-ace0-b293b83452b5"
},
"data": {
"timestamp": 1724716542
},
"score": 0.914321
},
{
"matches": {
"message": "direct to Narata"
},
"dataset": "app_messages",
"primary_key": {
"id": "8a25595f-99fb-4404-8c82-e1046d8f4c4b"
},
"data": {
"timestamp": 1724715881
},
"score": 0.83221
},
{
"matches": {
"message": "Yes, we're sitting together"
},
"dataset": "app_messages",
"primary_key": {
"id": "8421ed84-b86d-4b10-b4da-7a432e8912c0"
},
"data": {
"timestamp": 1724716123
},
"score": 0.787654321
}
],
"duration_ms": 42
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "No data sources provided"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"error": "Unexpected internal server error occurred"
}
POST
Text-to-SQL (NSQL)
{{baseUrl}}/v1/nsql
HEADERS
Accept
BODY json
{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/nsql");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/nsql" {:headers {:accept ""}
:content-type :json
:form-params {:datasets ""
:model ""
:query ""
:sample_data_enabled false
:stream false}})require "http/client"
url = "{{baseUrl}}/v1/nsql"
headers = HTTP::Headers{
"accept" => ""
"content-type" => "application/json"
}
reqBody = "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/nsql"),
Headers =
{
{ "accept", "" },
},
Content = new StringContent("{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/nsql");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/nsql"
payload := strings.NewReader("{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("accept", "")
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/nsql HTTP/1.1
Accept:
Content-Type: application/json
Host: example.com
Content-Length: 101
{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/nsql")
.setHeader("accept", "")
.setHeader("content-type", "application/json")
.setBody("{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/nsql"))
.header("accept", "")
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/nsql")
.post(body)
.addHeader("accept", "")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/nsql")
.header("accept", "")
.header("content-type", "application/json")
.body("{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}")
.asString(); const data = JSON.stringify({
datasets: '',
model: '',
query: '',
sample_data_enabled: false,
stream: false
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/nsql');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/nsql',
headers: {accept: '', 'content-type': 'application/json'},
data: {datasets: '', model: '', query: '', sample_data_enabled: false, stream: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/nsql';
const options = {
method: 'POST',
headers: {accept: '', 'content-type': 'application/json'},
body: '{"datasets":"","model":"","query":"","sample_data_enabled":false,"stream":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/nsql',
method: 'POST',
headers: {
accept: '',
'content-type': 'application/json'
},
processData: false,
data: '{\n "datasets": "",\n "model": "",\n "query": "",\n "sample_data_enabled": false,\n "stream": false\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}")
val request = Request.Builder()
.url("{{baseUrl}}/v1/nsql")
.post(body)
.addHeader("accept", "")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/nsql',
headers: {
accept: '',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({datasets: '', model: '', query: '', sample_data_enabled: false, stream: false}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/nsql',
headers: {accept: '', 'content-type': 'application/json'},
body: {datasets: '', model: '', query: '', sample_data_enabled: false, stream: false},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/nsql');
req.headers({
accept: '',
'content-type': 'application/json'
});
req.type('json');
req.send({
datasets: '',
model: '',
query: '',
sample_data_enabled: false,
stream: false
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/v1/nsql',
headers: {accept: '', 'content-type': 'application/json'},
data: {datasets: '', model: '', query: '', sample_data_enabled: false, stream: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/nsql';
const options = {
method: 'POST',
headers: {accept: '', 'content-type': 'application/json'},
body: '{"datasets":"","model":"","query":"","sample_data_enabled":false,"stream":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"accept": @"",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"datasets": @"",
@"model": @"",
@"query": @"",
@"sample_data_enabled": @NO,
@"stream": @NO };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/nsql"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/nsql" in
let headers = Header.add_list (Header.init ()) [
("accept", "");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/nsql",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'datasets' => '',
'model' => '',
'query' => '',
'sample_data_enabled' => null,
'stream' => null
]),
CURLOPT_HTTPHEADER => [
"accept: ",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/nsql', [
'body' => '{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}',
'headers' => [
'accept' => '',
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/v1/nsql');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'accept' => '',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'datasets' => '',
'model' => '',
'query' => '',
'sample_data_enabled' => null,
'stream' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'datasets' => '',
'model' => '',
'query' => '',
'sample_data_enabled' => null,
'stream' => null
]));
$request->setRequestUrl('{{baseUrl}}/v1/nsql');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'accept' => '',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/nsql' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}'$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/nsql' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}"
headers = {
'accept': "",
'content-type': "application/json"
}
conn.request("POST", "/baseUrl/v1/nsql", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/nsql"
payload = {
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": False,
"stream": False
}
headers = {
"accept": "",
"content-type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/nsql"
payload <- "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/nsql")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/v1/nsql') do |req|
req.headers['accept'] = ''
req.body = "{\n \"datasets\": \"\",\n \"model\": \"\",\n \"query\": \"\",\n \"sample_data_enabled\": false,\n \"stream\": false\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/nsql";
let payload = json!({
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("accept", "".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/nsql \
--header 'accept: ' \
--header 'content-type: application/json' \
--data '{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}'echo '{
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
}' | \
http POST {{baseUrl}}/v1/nsql \
accept:'' \
content-type:application/jsonwget --quiet \
--method POST \
--header 'accept: ' \
--header 'content-type: application/json' \
--body-data '{\n "datasets": "",\n "model": "",\n "query": "",\n "sample_data_enabled": false,\n "stream": false\n}' \
--output-document \
- {{baseUrl}}/v1/nsqlimport Foundation
let headers = [
"accept": "",
"content-type": "application/json"
]
let parameters = [
"datasets": "",
"model": "",
"query": "",
"sample_data_enabled": false,
"stream": false
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/nsql")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"customer_id": "12345",
"total_sales": 150000
},
{
"customer_id": "67890",
"total_sales": 125000
}
]RESPONSE HEADERS
Content-Type
application/sql
RESPONSE BODY text
SELECT customer_id, SUM(total_sales)
FROM sales_data
GROUP BY customer_id
ORDER BY SUM(total_sales) DESC
LIMIT 5
RESPONSE HEADERS
Content-Type
application/vnd.spiceai.nsql.v1+json
RESPONSE BODY text
{
"row_count": 2,
"schema": {
"fields": [
{
"name": "customer_id",
"data_type": "String",
"nullable": false,
"dict_id": 0,
"dict_is_ordered": false
},
{
"name": "total_sales",
"data_type": "Int64",
"nullable": false,
"dict_id": 0,
"dict_is_ordered": false
}
]
},
"data": [
{
"customer_id": "12345",
"total_sales": 150000
},
{
"customer_id": "67890",
"total_sales": 125000
}
],
"sql": "SELECT customer_id, SUM(total_sales) AS total_sales\nFROM sales_data\nGROUP BY customer_id\nORDER BY total_sales DESC\nLIMIT 5"
}RESPONSE HEADERS
Content-Type
text/event-stream
RESPONSE BODY text
data: {"row_count": 2, "schema": {...}, "data": [...], "sql": "SELECT ..."}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
Model nsql not foundRESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
No query produced from NSQL model
GET
List Tools
{{baseUrl}}/v1/tools
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/tools");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/v1/tools")require "http/client"
url = "{{baseUrl}}/v1/tools"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/v1/tools"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/tools");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/tools"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/v1/tools HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/tools")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/tools"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/tools")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/v1/tools")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/v1/tools');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/v1/tools'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/tools';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/tools',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/tools")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/tools',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/v1/tools'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/v1/tools');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/v1/tools'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/tools';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/tools"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/tools" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/tools",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/v1/tools');
echo $response->getBody();setUrl('{{baseUrl}}/v1/tools');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/tools');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/tools' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/tools' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/v1/tools")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/tools"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/tools"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/tools")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/v1/tools') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/tools";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/v1/toolshttp GET {{baseUrl}}/v1/toolswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/v1/toolsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/tools")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"name": "get_readiness",
"description": "Retrieves the readiness status of all runtime components including registered datasets, models, and embeddings.",
"parameters": null
},
{
"name": "list_datasets",
"description": "List all SQL tables available.",
"parameters": null
}
]
POST
Run Tool
{{baseUrl}}/v1/tools/:name
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/tools/:name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/v1/tools/:name")require "http/client"
url = "{{baseUrl}}/v1/tools/:name"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/v1/tools/:name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/v1/tools/:name");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/v1/tools/:name"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/v1/tools/:name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/tools/:name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/v1/tools/:name"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/v1/tools/:name")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/v1/tools/:name")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/v1/tools/:name');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/v1/tools/:name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/v1/tools/:name';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/v1/tools/:name',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/v1/tools/:name")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/v1/tools/:name',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/v1/tools/:name'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/v1/tools/:name');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/v1/tools/:name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/v1/tools/:name';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/tools/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/v1/tools/:name" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/v1/tools/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/v1/tools/:name');
echo $response->getBody();setUrl('{{baseUrl}}/v1/tools/:name');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/v1/tools/:name');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/tools/:name' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/tools/:name' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
payload = ""
conn.request("POST", "/baseUrl/v1/tools/:name", payload)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/v1/tools/:name"
payload = ""
response = requests.post(url, data=payload)
print(response.json())library(httr)
url <- "{{baseUrl}}/v1/tools/:name"
payload <- ""
response <- VERB("POST", url, body = payload, content_type(""))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/v1/tools/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/v1/tools/:name') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/v1/tools/:name";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/v1/tools/:namehttp POST {{baseUrl}}/v1/tools/:namewget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/v1/tools/:nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/tools/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"AVG(my_table.tip_amount)": 3.072259971396793,
"AVG(my_table.total_amount)": 25.327816939456525,
"COUNT(Int64(1))": 31465,
"passenger_count": 0
},
{
"AVG(my_table.tip_amount)": 3.3712622884680057,
"AVG(my_table.total_amount)": 26.205230445474996,
"COUNT(Int64(1))": 2188739,
"passenger_count": 1
},
{
"AVG(my_table.tip_amount)": 3.7171302113290854,
"AVG(my_table.total_amount)": 29.520659930930304,
"COUNT(Int64(1))": 405103,
"passenger_count": 2
}
]RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
Tool no_sql not foundRESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"message": "Error calling tool no_sql: No such tool"
}