curl --location 'https://your_domain.testgrid.io/api/user/applications' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/applications")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/applications"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/applications');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/applications")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/applications", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/applications"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/applications");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/create-application' \
--form 'user_token="<Your_User_Token>"' \
--form 'version_name="<Your_Version_Name>"' \
--form 'application_name="<Your_Application_Name>"' \
--form 'platform_type="<Your_Version_Platform_Type>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/create-application")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['version_name', '<Your_Version_Name>'],['application_name', '<Your_Application_Name>'],['platform_type', '<Your_Version_Platform_Type>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/create-application"

payload = {'user_token': '<Your_User_Token>',
'version_name': '<Your_Version_Name>',
'application_name': '<Your_Application_Name>',
'platform_type': '<Your_Version_Platform_Type>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'version_name',
'contents' => '<Your_Version_Name>'
],
[
'name' => 'application_name',
'contents' => '<Your_Application_Name>'
],
[
'name' => 'platform_type',
'contents' => '<Your_Version_Platform_Type>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/create-application');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("version_name","<Your_Version_Name>")
.addFormDataPart("application_name","<Your_Application_Name>")
.addFormDataPart("platform_type","<Your_Version_Platform_Type>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/create-application")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("version_name", "<Your_Version_Name>");
formdata.append("application_name", "<Your_Application_Name>");
formdata.append("platform_type", "<Your_Version_Platform_Type>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/create-application", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/create-application"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("version_name", "<Your_Version_Name>")
_ = writer.WriteField("application_name", "<Your_Application_Name>")
_ = writer.WriteField("platform_type", "<Your_Version_Platform_Type>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/create-application");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Version_Name>"), "version_name");
content.Add(new StringContent("<Your_Application_Name>"), "application_name");
content.Add(new StringContent("<Your_Version_Platform_Type>"), "platform_type");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/version/{{app_id}}/' \
--form 'user_token="<Your_User_Token>"' \
--form 'version_name="<Your_Version_Name>"' \
--form 'version_description="<Your_Version_Description>"' \
--form 'version_platform="<Your_Version_Platform_Type>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/version/{{app_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['version_name', '<Your_Version_Name>'],['version_description', '<Your_Version_Description>'],['version_platform', '<Your_Version_Platform_Type>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/version/{{app_id}}/"

payload = {'user_token': '<Your_User_Token>',
'version_name': '<Your_Version_Name>',
'version_description': '<Your_Version_Description>',
'version_platform': '<Your_Version_Platform_Type>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'version_name',
'contents' => '<Your_Version_Name>'
],
[
'name' => 'version_description',
'contents' => '<Your_Version_Description>'
],
[
'name' => 'version_platform',
'contents' => '<Your_Version_Platform_Type>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/version/{{app_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("version_name","<Your_Version_Name>")
.addFormDataPart("version_description","<Your_Version_Description>")
.addFormDataPart("version_platform","<Your_Version_Platform_Type>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/version/{{app_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("version_name", "<Your_Version_Name>");
formdata.append("version_description", "<Your_Version_Description>");
formdata.append("version_platform", "<Your_Version_Platform_Type>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/version/{{app_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/version/{{app_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("version_name", "<Your_Version_Name>")
_ = writer.WriteField("version_description", "<Your_Version_Description>")
_ = writer.WriteField("version_platform", "<Your_Version_Platform_Type>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/version/{{app_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Version_Name>"), "version_name");
content.Add(new StringContent("<Your_Version_Description>"), "version_description");
content.Add(new StringContent("<Your_Version_Platform_Type>"), "version_platform");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/applications/{{app_id}}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/applications/{{app_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/applications/{{app_id}}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/applications/{{app_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/applications/{{app_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/applications/{{app_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/applications/{{app_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/applications/{{app_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/buildinfo/<Your_App_Build_ID>/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/build/{{version_id}}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/build/{{version_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/build/{{version_id}}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/build/{{version_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/build/{{version_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/build/{{version_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/build/{{version_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/build/{{version_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/upload_app_build' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'version_token="<Your_Version_Token>"' \
--form 'upload_file=@"<Your_Uploaded_File>"' \
--form 'bundle_identifier="<Your_bundle_identifier>"' \
--form 'build_name="<Your_build_name>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/upload_app_build")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['version_token', '<Your_Version_Token>'],['upload_file', File.open('<Your_Uploaded_File>')],['bundle_identifier', '<Your_bundle_identifier>'],['build_name', '<Your_build_name>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/upload_app_build"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'version_token': '<Your_Version_Token>',
'bundle_identifier': '<Your_bundle_identifier>',
'build_name': '<Your_build_name>'}
files=[
('upload_file',('<Your_Uploaded_File>',open('','rb'),'application/octet-stream'))
]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'version_token',
'contents' => '<Your_Version_Token>'
],
[
'name' => 'upload_file',
'contents' => Utils::tryFopen('<Your_Uploaded_File>', 'r'),
'filename' => '<Your_Uploaded_File>',
'headers' => [
],
[
'name' => 'bundle_identifier',
'contents' => '<Your_bundle_identifier>'
],
[
'name' => 'build_name',
'contents' => '<Your_build_name>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/upload_app_build');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("version_token","<Your_Version_Token>")
.addFormDataPart("upload_file","<Your_Uploaded_File>",
RequestBody.create(MediaType.parse("application/octet-stream"),
new File("<Your_Uploaded_File>")))
.addFormDataPart("bundle_identifier","<Your_bundle_identifier>")
.addFormDataPart("build_name","<Your_build_name>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/upload_app_build")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("version_token", "<Your_Version_Token>");
formdata.append("upload_file", fileInput.files[0], "<Your_Uploaded_File>");
formdata.append("bundle_identifier", "<Your_bundle_identifier>");
formdata.append("build_name", "<Your_build_name>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/upload_app_build", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"os"
"path/filepath"
"io"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/upload_app_build"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("version_token", "<Your_Version_Token>")
file, errFile4 := os.Open("<Your_Uploaded_File>")
defer file.Close()
part4,
errFile4 := writer.CreateFormFile("upload_file",filepath.Base(""))
_, errFile4 = io.Copy(part4, file)
if errFile4 != nil {
fmt.Println(errFile4)
return
}
_ = writer.WriteField("bundle_identifier", "")
_ = writer.WriteField("build_name", "")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/upload_app_build");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_Version_Token>"), "version_token");
content.Add(new StreamContent(File.OpenRead("<Your_Uploaded_File>")), "upload_file", "");
content.Add(new StringContent("<Your_bundle_identifier>"), "bundle_identifier");
content.Add(new StringContent("<Your_build_name>"), "build_name");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/build/app-install' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'version_token="<Your_Version_Token>"' \
--form 'process_type="<Your_Process_Type>"' \
--form 's_device="<Your_s_device>"' \
--form 'app_build_id="<Your_App_Build_id>"' \
--form 'is_resign="<0 or 1>"' \
--form 'disable_secure_flag="<0 or 1>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/build/app-install")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['version_token', '<Your_Version_Token>'],['process_type', '<Your_Process_Type>'],['s_device', '<Your_s_device>'],['app_build_id', '<Your_App_Build_id>'],['is_resign', '<0 or 1>'],['disable_secure_flag', '<0 or 1>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/build/app-install"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'version_token': '<Your_Version_Token>',
'process_type': '<Your_Process_Type>',
's_device': '<Your_s_device>',
'app_build_id': '<Your_App_Build_id>',
'is_resign': '<0 or 1>',
'disable_secure_flag': '<0 or 1>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'version_token',
'contents' => '<Your_Version_Token>'
],
[
'name' => 'process_type',
'contents' => '<Your_Process_Type>'
],
[
'name' => 's_device',
'contents' => '<Your_s_device>'
],
[
'name' => 'app_build_id',
'contents' => '<Your_App_Build_id>'
],
[
'name' => 'is_resign',
'contents' => '<0 or 1>'
],
[
'name' => 'disable_secure_flag',
'contents' => '<0 or 1>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/build/app-install');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("version_token","<Your_Version_Token>")
.addFormDataPart("process_type","<Your_Process_Type>")
.addFormDataPart("s_device","<Your_s_device>")
.addFormDataPart("app_build_id","<Your_App_Build_id>")
.addFormDataPart("is_resign","<0 or 1>")
.addFormDataPart("disable_secure_flag","<0 or 1>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/build/app-install")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("version_token", "<Your_Version_Token>");
formdata.append("process_type", "<Your_Process_Type>");
formdata.append("s_device", "<Your_s_device>");
formdata.append("app_build_id", "<Your_App_Build_id>");
formdata.append("is_resign", "<0 or 1>");
formdata.append("disable_secure_flag", "<0 or 1>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/build/app-install", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/build/app-install"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("version_token", "<Your_Version_Token>")
_ = writer.WriteField("process_type", "<Your_Process_Type>")
_ = writer.WriteField("s_device", "<Your_s_device>")
_ = writer.WriteField("app_build_id", "<Your_App_Build_id>")
_ = writer.WriteField("is_resign", "<0 or 1>")
_ = writer.WriteField("disable_secure_flag", "<0 or 1>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/build/app-install");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_Version_Token>"), "version_token");
content.Add(new StringContent("<Your_Process_Type>"), "process_type");
content.Add(new StringContent("<Your_s_device>"), "s_device");
content.Add(new StringContent("<Your_App_Build_id>"), "app_build_id");
content.Add(new StringContent("<0 or 1>"), "is_resign");
content.Add(new StringContent("<0 or 1>"), "disable_secure_flag");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/app_build_install' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'version_token="<Your_Version_Token>"' \
--form 'process_type="<Your_Process_Type>"' \
--form 's_device="<Your_s_device>"' \
--form 'app_build_id="<Your_App_Build_id>"' \
--form 'is_resign="<0 or 1>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/app_build_install")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['version_token', '<Your_Version_Token>'],['process_type', '<Your_Process_Type>'],['s_device', '<Your_s_device>'],['app_build_id', '<Your_App_Build_id>'],['is_resign', '<0 or 1>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/app_build_install"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'version_token': '<Your_Version_Token>',
'process_type': '<Your_Process_Type>',
's_device': '<Your_s_device>',
'app_build_id': '<Your_App_Build_id>',
'is_resign': '<0 or 1>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'version_token',
'contents' => '<Your_Version_Token>'
],
[
'name' => 'process_type',
'contents' => '<Your_Process_Type>'
],
[
'name' => 's_device',
'contents' => '<Your_s_device>'
],
[
'name' => 'app_build_id',
'contents' => '<Your_App_Build_id>'
],
[
'name' => 'is_resign',
'contents' => '<0 or 1>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/app_build_install');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("version_token","<Your_Version_Token>")
.addFormDataPart("process_type","<Your_Process_Type>")
.addFormDataPart("s_device","<Your_s_device>")
.addFormDataPart("app_build_id","<Your_App_Build_id>")
.addFormDataPart("is_resign","<0 or 1>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/app_build_install")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("version_token", "<Your_Version_Token>");
formdata.append("process_type", "<Your_Process_Type>");
formdata.append("s_device", "<Your_s_device>");
formdata.append("app_build_id", "<Your_App_Build_id>");
formdata.append("is_resign", "<0 or 1>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/app_build_install", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/app_build_install"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("version_token", "<Your_Version_Token>")
_ = writer.WriteField("process_type", "<Your_Process_Type>")
_ = writer.WriteField("s_device", "<Your_s_device>")
_ = writer.WriteField("app_build_id", "<Your_App_Build_id>")
_ = writer.WriteField("is_resign", "<0 or 1>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/app_build_install");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_Version_Token>"), "version_token");
content.Add(new StringContent("<Your_Process_Type>"), "process_type");
content.Add(new StringContent("<Your_s_device>"), "s_device");
content.Add(new StringContent("<Your_App_Build_id>"), "app_build_id");
content.Add(new StringContent("<0 or 1>"), "is_resign");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/removebuilds/{{app_build_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/run-native-test-ios' \
--form 'user_token="<your_user_token>"' \
--form 'build_name="<Your_build_name>"' \
--form 'app_id="<Your_app_id>"' \
--form 'device_id="<Your_device_id>"' \
--form 'file=@"<Your_Uploaded_File>"' \
--form 'version_id="<Your_version_Id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/run-native-test-ios")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_user_token>'],['build_name', '<Your_build_name>'],['app_id', '<Your_app_id>'],['device_id', '<Your_device_id>'],['file', File.open('<Your_Uploaded_File>
')],['version_id', '<Your_version_Id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/run-native-test-ios"

payload = {'user_token': '<Your_user_token>',
'build_name': '<Your_build_name>',
'app_id': '<Your_app_id>',
'device_id': '<Your_device_id>',
'version_id': '<Your_version_Id>'}
files=[
('file',('<Your_Uploaded_File>
',open('<Your_Uploaded_File>','rb'),'application/octet-stream'))
]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_user_token>'
],
[
'name' => 'build_name',
'contents' => '<Your_build_name>'
],
[
'name' => 'app_id',
'contents' => '<Your_app_id>'
],
[
'name' => 'device_id',
'contents' => '<Your_device_id>'
],
[
'name' => 'file',
'contents' => Utils::tryFopen('<Your_Uploaded_File>
', 'r'),
'filename' => '<Your_Uploaded_File>',
'headers' => [
'Content-Type' => '<Content-type header>'
]
],
[
'name' => 'version_id',
'contents' => '<Your_version_Id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/run-native-test-ios');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_user_token>")
.addFormDataPart("build_name","<Your_build_name>")
.addFormDataPart("app_id","<Your_app_id>")
.addFormDataPart("device_id","<Your_device_id>")
.addFormDataPart("file","<Your_Uploaded_File>",
RequestBody.create(MediaType.parse("application/octet-stream"),
new File("<Your_Uploaded_File>
")))
.addFormDataPart("version_id","<Your_version_Id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/run-native-test-ios")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_user_token>\r");
formdata.append("build_name", "<Your_build_name>\r");
formdata.append("app_id", "<Your_app_id>\r");
formdata.append("device_id", "<Your_device_id>\r");
formdata.append("file", fileInput.files[0], "<Your_Uploaded_File>
");
formdata.append("version_id", "<Your_version_Id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/run-native-test-ios", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"os"
"path/filepath"
"io"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/run-native-test-ios"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_user_token>\r")
_ = writer.WriteField("build_name", "<Your_build_name>\r")
_ = writer.WriteField("app_id", "<Your_app_id>\r")
_ = writer.WriteField("device_id", "<Your_device_id>\r")
file, errFile5 := os.Open("<Your_Uploaded_File>
")
defer file.Close()
part5,
errFile5 := writer.CreateFormFile("file",filepath.Base("<Your_Uploaded_File>
"))
_, errFile5 = io.Copy(part5, file)
if errFile5 != nil {
fmt.Println(errFile5)
return
}
_ = writer.WriteField("version_id", "<Your_version_Id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/run-native-test-ios");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_user_token>
"), "user_token");
content.Add(new StringContent("<Your_build_name>
"), "build_name");
content.Add(new StringContent("<Your_app_id>
"), "app_id");
content.Add(new StringContent("<Your_device_id>
"), "device_id");
content.Add(new StreamContent(File.OpenRead("<Your_Uploaded_File>
")), "file", "<Your_Uploaded_File>
");
content.Add(new StringContent("<Your_version_Id>"), "version_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/run-native-test' \
--form 'user_token="<your_user_token>"' \
--form 'build_name="<Your_build_name>"' \
--form 'app_build_id="<Your_app_build_id>"' \
--form 'device_id="<Your_device_id>"' \
--form 'file=@"<Your_Uploaded_File>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/run-native-test")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<your_user_token>'],['build_name', '<Your_build_name>'],['app_build_id', '<Your_app_build_id>'],['device_id', '<Your_device_id>'],['file', File.open('<Your_Uploaded_File>')]]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/run-native-test"

payload = {'user_token': '<your_user_token>',
'build_name': '<Your_build_name>',
'app_build_id': '<Your_app_build_id>',
'device_id': '<Your_device_id>'}
files=[
('file',('<Your_Uploaded_File>',open('','rb'),'application/octet-stream'))
]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<your_user_token>'
],
[
'name' => 'build_name',
'contents' => '<Your_build_name>'
],
[
'name' => 'app_build_id',
'contents' => '<Your_app_build_id>'
],
[
'name' => 'device_id',
'contents' => '<Your_device_id>'
],
[
'name' => 'file',
'contents' => Utils::tryFopen('', 'r'),
'filename' => '<Your_Uploaded_File>',
'headers' => [
]
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/run-native-test');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<your_user_token>")
.addFormDataPart("build_name","<Your_build_name>")
.addFormDataPart("app_build_id","<Your_app_build_id>")
.addFormDataPart("device_id","<Your_device_id>")
.addFormDataPart("file","<Your_Uploaded_File>",
RequestBody.create(MediaType.parse("application/octet-stream"),
new File("<Your_Uploaded_File>")))
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/run-native-test")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<your_user_token>\r");
formdata.append("build_name", "<Your_build_name>\r");
formdata.append("app_build_id", "<Your_app_build_id>\r");
formdata.append("device_id", "<Your_device_id>\r");
formdata.append("file", fileInput.files[0], "<Your_Uploaded_File>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/run-native-test", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"os"
"path/filepath"
"io"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/run-native-test"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<your user token>\r")
_ = writer.WriteField("build_name", "<Your_build_name>\r")
_ = writer.WriteField("app_build_id", "<Your_app_build_id>\r")
_ = writer.WriteField("device_id", "<Your_device_id>\r")
file, errFile5 := os.Open("<Your_Uploaded_File>")
defer file.Close()
part5,
errFile5 := writer.CreateFormFile("file",filepath.Base("<Your_Uploaded_File>"))
_, errFile5 = io.Copy(part5, file)
if errFile5 != nil {
fmt.Println(errFile5)
return
}
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/run-native-test");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<your_user_token>"), "user_token");
content.Add(new StringContent("<Your_build_name>"), "build_name");
content.Add(new StringContent("<Your_app_build_id>"), "app_build_id");
content.Add(new StringContent("<Your_device_id>"), "device_id");
content.Add(new StreamContent(File.OpenRead("<Your_Uploaded_File>")), "file", "<Your_Uploaded_File>");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/get-native-test-result' \
--form 'user_token="<Your_User_Token>"'
--form 'native_test_build_id="<Your_Native_Test_build_id>"'

require "uri"
require "json"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/get-native-test-result")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request.body = JSON.dump({
"user_token": "<Your_User_Token>",
"native_test_build_id": "<Your_Native_Test_build_id>"
})

response = https.request(request)
puts response.read_body

import requests
import json

url = "https://your_domain.testgrid.io/api/get-native-test-result"

payload = json.dumps({
"user_token": "<Your_User_Token>",
"native_test_build_id": "<Your_Native_Test_build_id>"
})
headers = {
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

<?php
$client = new Client();
$headers = [
];
$body = '{
"user_token": "<Your_User_Token>",
"native_test_build_id": "<Your_Native_Test_build_id>"
}';
$request = new Request('POST', 'https://your_domain.testgrid.io/api/get-native-test-result', $headers, $body);
$res = $client->sendAsync($request)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{
\"user_token\": \"<Your_User_Token>\",
\"native_test_build_id\": \"<Your_Native_Test_build_id>\"
}");
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/get-native-test-result")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var myHeaders = new Headers();

var raw = JSON.stringify({
"user_token": "<Your_User_Token>",
"native_test_build_id": "<Your_Native_Test_build_id>"
});

var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/get-native-test-result", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/get-native-test-result"
method := "POST"

payload := strings.NewReader(`{
"user_token": "<Your_User_Token>",
"native_test_build_id": "<Your_Native_Test_build_id>"
}`)

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}

res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/get-native-test-result");
var content = new StringContent("{
\"user_token\": \"<Your_User_Token>\",
\"native_test_build_id\": \"<Your_Native_Test_build_id>\"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/app-upload' \
--form 'user_token="<Your_User_token>"' \
--form 'platform="\"iOS or Android"' \
--form 'upload_file=@"<Your_Uploaded_File>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/app-upload")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_token>'],['platform', '"iOS or Android'],['upload_file', File.open('<Your_Uploaded_File>')]]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/app-upload"

payload = {'user_token': '<Your_User_token>',
'platform': '"iOS or Android'}
files=[
('upload_file',('<Your_Uploaded_File>',open('','rb'),'application/octet-stream'))
]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_token>'
],
[
'name' => 'platform',
'contents' => '"iOS or Android'
],
[
'name' => 'upload_file',
'contents' => Utils::tryFopen('', 'r'),
'filename' => '<Your_Uploaded_File>',
'headers' => [
'Content-Type' => '<Your_Uploaded_File>'
]
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/app-upload');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_token>")
.addFormDataPart("platform","\"iOS or Android")
.addFormDataPart("upload_file","<Your_Uploaded_File>",
RequestBody.create(MediaType.parse("application/octet-stream"),
new File("<Your_Uploaded_File>")))
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/app-upload")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_token>");
formdata.append("platform", "\"iOS or Android");
formdata.append("upload_file", fileInput.files[0], ""<Your_Uploaded_File>);

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/app-upload", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"os"
"path/filepath"
"io"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/app-upload"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_token>")
_ = writer.WriteField("platform", "\"iOS or Android")
file, errFile3 := os.Open("<Your_Uploaded_File>")
defer file.Close()
part3,
errFile3 := writer.CreateFormFile("upload_file",filepath.Base(""))
_, errFile3 = io.Copy(part3, file)
if errFile3 != nil {
fmt.Println(errFile3)
return
}
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/app-upload");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_token>"), "user_token");
content.Add(new StringContent("\"iOS or Android"), "platform");
content.Add(new StreamContent(File.OpenRead("<Your_Uploaded_File>")), "upload_file", "");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/app-install' \
--form 'user_token="<Your_user_token>"' \
--form 'app_build_id="<Your_App_Build_id>"' \
--form 'device_id="<Your_Device_Id>"' \
--form 'is_resign="<0 or 1>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/app-install")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_user_token>'],['app_build_id', '<Your_App_Build_id>'],['device_id', '<Your_Device_Id>'],['is_resign', '<0 or 1>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/app-install"

payload = {'user_token': '<Your_user_token>',
'app_build_id': '<Your_App_Build_id>',
'device_id': '<Your_Device_Id>',
'is_resign': '<0 or 1>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_user_token>'
],
[
'name' => 'app_build_id',
'contents' => '<Your_App_Build_id>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_Id>'
],
[
'name' => 'is_resign',
'contents' => '<0 or 1>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/app-install');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_user_token>")
.addFormDataPart("app_build_id","<Your_App_Build_id>")
.addFormDataPart("device_id","<Your_Device_Id>")
.addFormDataPart("is_resign","<0 or 1>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/app-install")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_user_token>\r");
formdata.append("app_build_id", "<Your_App_Build_id>\r");
formdata.append("device_id", "<Your_Device_Id>");
formdata.append("is_resign", "<0 or 1>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/app-install", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/app-install"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_user_token>\r")
_ = writer.WriteField("app_build_id", "<Your_App_Build_id>\r")
_ = writer.WriteField("device_id", "<Your_Device_Id>")
_ = writer.WriteField("is_resign", "<0 or 1>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/app-install");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_user_token>"), "user_token");
content.Add(new StringContent("<Your_App_Build_id>"), "app_build_id");
content.Add(new StringContent("<Your_Device_Id>"), "device_id");
content.Add(new StringContent("<0 or 1>"), "is_resign");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/device/app-auto-launch' \
--header 'Cookie: _testgrid=f0e358109b1818071f8157995e8f9b16' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_id="<Your_Device_id>"' \
--form 'bundle_id="<Your_bundle_id>"'

require 'net/http'
require 'uri'

uri = URI.parse("https://your_domain.testgrid.io/api/device/app-auto-launch")

request = Net::HTTP::Post.new(uri)
request["Cookie"] = "_testgrid=f0e358109b1818071f8157995e8f9b16"

form_data = [
['user_token', '<Your_User_Token>'],
['device_id', '<Your_Device_id>'],
['bundle_id', '<Your_bundle_id>']
]

request.set_form form_data, 'multipart/form-data'

response = Net::HTTP.start(uri.hostname, uri.port,
use_ssl: uri.scheme == "https") do |http|
http.request(request)
end

puts response.body

import requests

url = "https://your_domain.testgrid.io/api/device/app-auto-launch"

headers = {
"Cookie": "_testgrid=f0e358109b1818071f8157995e8f9b16"
}

data = {
"user_token": "<Your_User_Token>",
"device_id": "<Your_Device_id>",
"bundle_id": "<Your_bundle_id>"
}

response = requests.post(url, headers=headers, data=data)

print("Status Code:", response.status_code)
print("Response:", response.text)

<?php

$url = "https://your_domain.testgrid.io/api/device/app-auto-launch";

$ch = curl_init();

curl_setopt_array($ch, [
CURLOPT_URL => $url,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POST => true,
CURLOPT_HTTPHEADER => [
"Cookie: _testgrid=f0e358109b1818071f8157995e8f9b16"
],
CURLOPT_POSTFIELDS => [
"user_token" => "<Your_User_Token>",
"device_id" => "<Your_Device_id>",
"bundle_id" => "<Your_bundle_id>"
],
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

curl_close($ch);

echo "Status Code: " . $httpCode . "\n";
echo "Response: " . $response;

import okhttp3.*;

import java.io.IOException;

public class AppAutoLaunch {
public static void main(String[] args) throws IOException {

OkHttpClient client = new OkHttpClient();

RequestBody body = new MultipartBody.Builder()
.setType(MultipartBody.FORM)
.addFormDataPart("user_token", "<Your_User_Token>")
.addFormDataPart("device_id", "<Your_Device_id>")
.addFormDataPart("bundle_id", "<Your_bundle_id>")
.build();

Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/device/app-auto-launch")
.addHeader("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16")
.post(body)
.build();

Response response = client.newCall(request).execute();

System.out.println("Status Code: " + response.code());
System.out.println("Response: " + response.body().string());
}
}

const axios = require('axios');
const FormData = require('form-data');

const form = new FormData();
form.append('user_token', '<Your_User_Token>');
form.append('device_id', '<Your_Device_id>');
form.append('bundle_id', '<Your_bundle_id>');

axios.post(
'https://your_domain.testgrid.io/api/device/app-auto-launch',
form,
{
headers: {
...form.getHeaders(),
'Cookie': '_testgrid=f0e358109b1818071f8157995e8f9b16'
}
}
)
.then(response => {
console.log('Status Code:', response.status);
console.log('Response:', response.data);
})
.catch(error => {
console.error('Error:', error.response?.data || error.message);
});

package main

import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
)

func main() {
url := "https://your_domain.testgrid.io/api/device/app-auto-launch"

var requestBody bytes.Buffer
writer := multipart.NewWriter(&requestBody)

// Add form fields
writer.WriteField("user_token", "<Your_User_Token>")
writer.WriteField("device_id", "<Your_Device_id>")
writer.WriteField("bundle_id", "<Your_bundle_id>")

writer.Close()

req, err := http.NewRequest("POST", url, &requestBody)
if err != nil {
panic(err)
}

req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()

body, _ := io.ReadAll(resp.Body)

fmt.Println("Status Code:", resp.StatusCode)
fmt.Println("Response:", string(body))
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
static async Task Main()
{
var url = "https://your_domain.testgrid.io/api/device/app-auto-launch";

using var client = new HttpClient();

client.DefaultRequestHeaders.Add("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16");

using var form = new MultipartFormDataContent
{
{ new StringContent("<Your_User_Token>"), "user_token" },
{ new StringContent("<Your_Device_id>"), "device_id" },
{ new StringContent("<Your_bundle_id>"), "bundle_id" }
};

var response = await client.PostAsync(url, form);
var responseBody = await response.Content.ReadAsStringAsync();

Console.WriteLine($"Status Code: {response.StatusCode}");
Console.WriteLine($"Response: {responseBody}");
}
}

curl --location 'https://your_domain.testgrid.io/api/device/install/biometric-bypass' \
--header 'Cookie: _testgrid=f0e358109b1818071f8157995e8f9b16' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_id="<Your_Device_id>"' \
--form 'apk_ipa_file=@"File.open('<Your_Uploaded_File>')"' \
--form 'biometric_status="pass"' \
--form 'resign="false"'

require 'net/http'
require 'uri'
require 'json'
require 'net/http/post/multipart'

uri = URI.parse("https://your_domain.testgrid.io/api/device/install/biometric-bypass")

# Build the request
request = Net::HTTP::Post::Multipart.new(
uri.path,
"user_token" => "<Your_User_Token>",
"device_id" => "<Your_Device_id>",
"apk_ipa_file" => UploadIO.new(
File.open("<Your_Uploaded_File>"),
"application/octet-stream",
File.basename("<Your_Uploaded_File>")
),
"biometric_status" => "pass",
"resign" => "false"
)

# Headers
request["Cookie"] = "_testgrid=f0e358109b1818071f8157995e8f9b16"

# Send request
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

response = http.request(request)

puts response.code
puts response.body

import requests

url = "https://your_domain.testgrid.io/api/device/install/biometric-bypass"

headers = {
"Cookie": "_testgrid=f0e358109b1818071f8157995e8f9b16"
}

data = {
"user_token": "<Your_User_Token>",
"device_id": "<Your_Device_id>",
"biometric_status": "pass",
"resign": "false"
}

files = {
"apk_ipa_file": open("<Your_Uploaded_File>", "rb")
}

response = requests.post(
url,
headers=headers,
data=data,
files=files
)

print("Status Code:", response.status_code)
print("Response:", response.text)

<?php

$url = "https://your_domain.testgrid.io/api/device/install/biometric-bypass";

$headers = [
"Cookie: _testgrid=f0e358109b1818071f8157995e8f9b16"
];

$postFields = [
"user_token" => "<Your_User_Token>",
"device_id" => "<Your_Device_id>",
"biometric_status" => "pass",
"resign" => "false",
"apk_ipa_file" => new CURLFile(
"<Your_Uploaded_File>",
"application/octet-stream",
basename("<Your_Uploaded_File>")
)
];

$ch = curl_init($url);
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_HTTPHEADER => $headers,
CURLOPT_POSTFIELDS => $postFields,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_SSL_VERIFYPEER => true,
]);

$response = curl_exec($ch);

if ($response === false) {
echo "cURL Error: " . curl_error($ch);
} else {
echo "Response: " . $response;
}

curl_close($ch);

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class BiometricBypassUpload {

public static void main(String[] args) throws Exception {

String boundary = "----WebKitFormBoundary" + UUID.randomUUID();
String url = "https://your_domain.testgrid.io/api/device/install/biometric-bypass";

HttpRequest.BodyPublisher body = ofMimeMultipartData(
boundary,
"<Your_User_Token>",
"<Your_Device_id>",
"pass",
"false",
new File("<Your_Uploaded_File>")
);

HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.header("Content-Type", "multipart/form-data; boundary=" + boundary)
.header("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16")
.POST(body)
.build();

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

System.out.println("Status Code: " + response.statusCode());
System.out.println("Response: " + response.body());
}

private static HttpRequest.BodyPublisher ofMimeMultipartData(
String boundary,
String userToken,
String deviceId,
String biometricStatus,
String resign,
File file
) throws IOException {

List<byte[]> byteArrays = new ArrayList<>();
String separator = "--" + boundary + "\r\n";
String ending = "--" + boundary + "--";

// user_token
byteArrays.add((separator +
"Content-Disposition: form-data; name=\"user_token\"\r\n\r\n" +
userToken + "\r\n").getBytes(StandardCharsets.UTF_8));

// device_id
byteArrays.add((separator +
"Content-Disposition: form-data; name=\"device_id\"\r\n\r\n" +
deviceId + "\r\n").getBytes(StandardCharsets.UTF_8));

// biometric_status
byteArrays.add((separator +
"Content-Disposition: form-data; name=\"biometric_status\"\r\n\r\n" +
biometricStatus + "\r\n").getBytes(StandardCharsets.UTF_8));

// resign
byteArrays.add((separator +
"Content-Disposition: form-data; name=\"resign\"\r\n\r\n" +
resign + "\r\n").getBytes(StandardCharsets.UTF_8));

// file
byteArrays.add((separator +
"Content-Disposition: form-data; name=\"apk_ipa_file\"; filename=\"" + file.getName() + "\"\r\n" +
"Content-Type: application/octet-stream\r\n\r\n")
.getBytes(StandardCharsets.UTF_8));

byteArrays.add(Files.readAllBytes(file.toPath()));
byteArrays.add("\r\n".getBytes(StandardCharsets.UTF_8));

// end boundary
byteArrays.add(ending.getBytes(StandardCharsets.UTF_8));

return HttpRequest.BodyPublishers.ofByteArrays(byteArrays);
}
}

const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");

const url = "https://your_domain.testgrid.io/api/device/install/biometric-bypass";

const form = new FormData();
form.append("user_token", "<Your_User_Token>");
form.append("device_id", "<Your_Device_id>");
form.append("biometric_status", "pass");
form.append("resign", "false");
form.append("apk_ipa_file", fs.createReadStream("<Your_Uploaded_File>"));

axios.post(url, form, {
headers: {
...form.getHeaders(),
Cookie: "_testgrid=f0e358109b1818071f8157995e8f9b16"
},
maxBodyLength: Infinity,
maxContentLength: Infinity
})
.then(response => {
console.log("Status:", response.status);
console.log("Response:", response.data);
})
.catch(error => {
if (error.response) {
console.error("Error:", error.response.status, error.response.data);
} else {
console.error("Error:", error.message);
}
});

package main

import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
)

func main() {

url := "https://your_domain.testgrid.io/api/device/install/biometric-bypass"

file, err := os.Open("<Your_Uploaded_File>")
if err != nil {
panic(err)
}
defer file.Close()

body := &bytes.Buffer{}
writer := multipart.NewWriter(body)

// Normal fields
writer.WriteField("user_token", "<Your_User_Token>")
writer.WriteField("device_id", "<Your_Device_id>")
writer.WriteField("biometric_status", "pass")
writer.WriteField("resign", "false")

// File field
part, err := writer.CreateFormFile("apk_ipa_file", file.Name())
if err != nil {
panic(err)
}
io.Copy(part, file)

writer.Close()

req, err := http.NewRequest("POST", url, body)
if err != nil {
panic(err)
}

req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()

respBody, _ := io.ReadAll(resp.Body)

fmt.Println("Status Code:", resp.StatusCode)
fmt.Println("Response:", string(respBody))
}

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
static async Task Main()
{
var url = "https://your_domain.testgrid.io/api/device/install/biometric-bypass";

using var client = new HttpClient();

// Cookie header
client.DefaultRequestHeaders.Add(
"Cookie",
"_testgrid=f0e358109b1818071f8157995e8f9b16"
);

using var form = new MultipartFormDataContent();

// Form fields
form.Add(new StringContent("<Your_User_Token>"), "user_token");
form.Add(new StringContent("<Your_Device_id>"), "device_id");
form.Add(new StringContent("pass"), "biometric_status");
form.Add(new StringContent("false"), "resign");

// File upload
var fileStream = File.OpenRead("<Your_Uploaded_File>");
var fileContent = new StreamContent(fileStream);
fileContent.Headers.ContentType =
new MediaTypeHeaderValue("application/octet-stream");

form.Add(fileContent, "apk_ipa_file", Path.GetFileName("<Your_Uploaded_File>"));

var response = await client.PostAsync(url, form);
var responseBody = await response.Content.ReadAsStringAsync();

Console.WriteLine("Status Code: " + response.StatusCode);
Console.WriteLine("Response: " + responseBody);
}
}

curl --location 'https://your_domain.testgrid.io/api/device/install/image-injection' \
--header 'Cookie: _testgrid=f0e358109b1818071f8157995e8f9b16' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_id="<Your_device_id>"' \
--form 'apk_ipa_file=@"File.open('<Your_Uploaded_File>')"' \
--form 'image=@"<Your_Image>"' \
--form 'resign=""'

require 'net/http'
require 'uri'

uri = URI.parse("https://your_domain.testgrid.io/api/device/install/image-injection")

request = Net::HTTP::Post.new(uri)
request["Cookie"] = "_testgrid=f0e358109b1818071f8157995e8f9b16"

form_data = [
['user_token', '<Your_User_Token>'],
['device_id', '<Your_device_id>'],
['apk_ipa_file', File.open('<Your_Uploaded_File>')],
['image', '<Your_Image>'],
['resign', '']
]

request.set_form(form_data, 'multipart/form-data')

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

response = http.request(request)

puts response.code
puts response.body

import requests

url = "https://your_domain.testgrid.io/api/device/install/image-injection"

data = {
"user_token": "<Your_User_Token>",
"device_id": "<Your_device_id>",
"resign": ""
}

files = {
"apk_ipa_file": open("<Your_Uploaded_File>", "rb"),
"image": open("<Your_Image>", "rb")
}

response = requests.post(url, data=data, files=files)

print(response.status_code)
print(response.text)

<?php

$url = "https://your_domain.testgrid.io/api/device/install/image-injection";

$postFields = [
'user_token' => '<Your_User_Token>',
'device_id' => '<Your_device_id>',
'resign' => '',
'apk_ipa_file' => new CURLFile(
'<Your_Uploaded_File>',
'application/octet-stream',
basename('<Your_Uploaded_File>')
),
'image' => new CURLFile(
'<Your_Image>',
'image/png',
basename('<Your_Image>')
),
];

$ch = curl_init($url);

curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => $postFields,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
'Cookie: _testgrid=f0e358109b1818071f8157995e8f9b16'
],
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

if ($response === false) {
echo 'cURL Error: ' . curl_error($ch);
}

curl_close($ch);

echo "HTTP Code: " . $httpCode . PHP_EOL;
echo $response;

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.File;

public class ImageInjectionUpload {

public static void main(String[] args) throws Exception {

String url = "https://your_domain.testgrid.io/api/device/install/image-injection";

HttpPost post = new HttpPost(url);

// Cookie header
post.setHeader("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16");

MultipartEntityBuilder builder = MultipartEntityBuilder.create();

// Text fields
builder.addTextBody("user_token", "<Your_User_Token>");
builder.addTextBody("device_id", "<Your_device_id>");
builder.addTextBody("resign", "");

// File fields
builder.addBinaryBody(
"apk_ipa_file",
new File("<Your_Uploaded_File>"),
ContentType.APPLICATION_OCTET_STREAM,
new File("<Your_Uploaded_File>").getName()
);

builder.addBinaryBody(
"image",
new File("<Your_Image>"),
ContentType.IMAGE_PNG,
new File("<Your_Image>").getName()
);

HttpEntity multipart = builder.build();
post.setEntity(multipart);

try (CloseableHttpClient client = HttpClients.createDefault();
CloseableHttpResponse response = client.execute(post)) {

System.out.println("HTTP Status: " + response.getStatusLine().getStatusCode());
System.out.println(EntityUtils.toString(response.getEntity()));
}
}
}

const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");

const url = "https://your_domain.testgrid.io/api/device/install/image-injection";

const form = new FormData();

// Text fields
form.append("user_token", "<Your_User_Token>");
form.append("device_id", "<Your_device_id>");
form.append("resign", "");

// File fields
form.append(
"apk_ipa_file",
fs.createReadStream("<Your_Uploaded_File>")
);

form.append(
"image",
fs.createReadStream("<Your_Image>")
);

axios.post(url, form, {
headers: {
...form.getHeaders(),
"Cookie": "_testgrid=f0e358109b1818071f8157995e8f9b16"
},
maxBodyLength: Infinity, // important for large APKs
maxContentLength: Infinity
})
.then(response => {
console.log("Status:", response.status);
console.log(response.data);
})
.catch(error => {
if (error.response) {
console.error("Error:", error.response.status, error.response.data);
} else {
console.error("Error:", error.message);
}
});

package main

import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
)

func main() {
url := "https://your_domain.testgrid.io/api/device/install/image-injection"

body := &bytes.Buffer{}
writer := multipart.NewWriter(body)

// Text fields
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_id", "<Your_device_id>")
_ = writer.WriteField("resign", "")

// APK / IPA file
apkFile, err := os.Open("<Your_Uploaded_File>")
if err != nil {
panic(err)
}
defer apkFile.Close()

apkPart, err := writer.CreateFormFile("apk_ipa_file", "app.apk")
if err != nil {
panic(err)
}
_, _ = io.Copy(apkPart, apkFile)

// Image file
imageFile, err := os.Open("<Your_Image>")
if err != nil {
panic(err)
}
defer imageFile.Close()

imagePart, err := writer.CreateFormFile("image", "screenshot.png")
if err != nil {
panic(err)
}
_, _ = io.Copy(imagePart, imageFile)

// Close writer (important!)
writer.Close()

req, err := http.NewRequest("POST", url, body)
if err != nil {
panic(err)
}

// Headers
req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("Cookie", "_testgrid=f0e358109b1818071f8157995e8f9b16")

client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()

respBody, _ := io.ReadAll(resp.Body)

fmt.Println("HTTP Status:", resp.StatusCode)
fmt.Println(string(respBody))
}

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
static async Task Main()
{
var url = "https://your_domain.testgrid.io/api/device/install/image-injection";

using var client = new HttpClient();

// Cookie header
client.DefaultRequestHeaders.Add(
"Cookie",
"_testgrid=f0e358109b1818071f8157995e8f9b16"
);

using var form = new MultipartFormDataContent();

// Text fields
form.Add(new StringContent("<Your_User_Token>"), "user_token");
form.Add(new StringContent("<Your_device_id>"), "device_id");
form.Add(new StringContent(""), "resign");

// APK / IPA file
var apkStream = File.OpenRead("<Your_Uploaded_File>");
var apkContent = new StreamContent(apkStream);
apkContent.Headers.ContentType =
new MediaTypeHeaderValue("application/octet-stream");

form.Add(apkContent, "apk_ipa_file", Path.GetFileName("<Your_Uploaded_File>"));

// Image file
var imageStream = File.OpenRead("<Your_Image>");
var imageContent = new StreamContent(imageStream);
imageContent.Headers.ContentType =
new MediaTypeHeaderValue("image/png");

form.Add(imageContent, "image", Path.GetFileName("<Your_Image>"));

// Send request
var response = await client.PostAsync(url, form);
var responseBody = await response.Content.ReadAsStringAsync();

Console.WriteLine("HTTP Status: " + response.StatusCode);
Console.WriteLine(responseBody);
}
}

curl --location 'https://your_domain.testgrid.io/api/get-user-devices' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/get-user-devices")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/get-user-devices"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/get-user-devices');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/get-user-devices")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/get-user-devices", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/get-user-devices"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/get-user-devices");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/get-devices-info' \
--form 'user_token="<Your_User_Token>"' \
--form 'platform_version="<Your_Platform_Version>"' \
--form 'device_type="<Your_Device_Type>"' \
--form 'device_id="<Your_Device_Id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/get-devices-info")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['platform_version', '<Your_Platform_Version>'],['device_type', '<Your_Device_Type>'],['device_id', '<Your_Device_Id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/get-devices-info"

payload = {'user_token': '<Your_User_Token>',
'platform_version': '<Your_Platform_Version>',
'device_type': '<Your_Device_Type>',
'device_id': '<Your_Device_Id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'platform_version',
'contents' => '<Your_Platform_Version>'
],
[
'name' => 'device_type',
'contents' => '<Your_Device_Type>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_Id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/get-devices-info');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("platform_version","<Your_Platform_Version>")
.addFormDataPart("device_type","<Your_Device_Type>")
.addFormDataPart("device_id","<Your_Device_Id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/get-devices-info")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("platform_version", "<Your_Platform_Version>");
formdata.append("device_type", "<Your_Device_Type>");
formdata.append("device_id", "<Your_Device_Id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/get-devices-info", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/get-devices-info"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("platform_version", "<Your_Platform_Version>")
_ = writer.WriteField("device_type", "<Your_Device_Type>")
_ = writer.WriteField("device_id", "<Your_Device_Id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/get-devices-info");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Platform_Version>"), "platform_version");
content.Add(new StringContent("<Your_Device_Type>"), "device_type");
content.Add(new StringContent("<Your_Device_Id>"), "device_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/device-logs/{device_id}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/device-logs/{device_id}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/device-logs/{device_id}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/device-logs/{device_id}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/device-logs/{device_id}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/device-logs/{device_id}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/device-logs/{device_id}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/device-logs/{device_id}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/user/builds' \
--form 'user_token="<Your_User_Token>"' \
--form 'project_name="<Your_Project_Name>"' \
--form 'device_id="<Your_Device_ID>"' \
--form 'build_number="<Your_Build_Number>"' \
--form 'last_minutes="<Your_Last_Minutes>"' \
--form 'session_name="<Your_Session_Name>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/builds")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['project_name', '<Your_Project_Name>'],['device_id', '<Your_Device_ID>'],['build_number', '<Your_Build_Number>'],['last_minutes', '<Your_Last_Minutes>'],['session_name', '<Your_Session_Name>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/builds"

payload = {'user_token': '<Your_User_Token>',
'project_name': '<Your_Project_Name>',
'device_id': '<Your_Device_ID>',
'build_number': '<Your_Build_Number>',
'last_minutes': '<Your_Last_Minutes>',
'session_name': '<Your_Session_Name>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'project_name',
'contents' => '<Your_Project_Name>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_ID>'
],
[
'name' => 'build_number',
'contents' => '<Your_Build_Number>'
],
[
'name' => 'last_minutes',
'contents' => '<Your_Last_Minutes>'
],
[
'name' => 'session_name',
'contents' => '<Your_Session_Name>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/builds');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("project_name","<Your_Project_Name>")
.addFormDataPart("device_id","<Your_Device_ID>")
.addFormDataPart("build_number","<Your_Build_Number>")
.addFormDataPart("last_minutes","<Your_Last_Minutes>")
.addFormDataPart("session_name","<Your_Session_Name>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/builds")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("project_name", "<Your_Project_Name>");
formdata.append("device_id", "<Your_Device_ID>");
formdata.append("build_number", "<Your_Build_Number>");
formdata.append("last_minutes", "<Your_Last_Minutes>");
formdata.append("session_name", "<Your_Session_Name>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/builds", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/builds"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("project_name", "<Your_Project_Name>")
_ = writer.WriteField("device_id", "<Your_Device_ID>")
_ = writer.WriteField("build_number", "<Your_Build_Number>")
_ = writer.WriteField("last_minutes", "<Your_Last_Minutes>")
_ = writer.WriteField("session_name", "<Your_Session_Name>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/builds");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Project_Name>"), "project_name");
content.Add(new StringContent("<Your_Device_ID>"), "device_id");
content.Add(new StringContent("<Your_Build_Number>"), "build_number");
content.Add(new StringContent("<Your_Last_Minutes>"), "last_minutes");
content.Add(new StringContent("<Your_Session_Name>"), "session_name");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/logs/{{build_number}}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/logs/{{build_number}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/logs/{{build_number}}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/logs/{{build_number}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/logs/{{build_number}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/logs/{{build_number}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/logs/{{build_number}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/logs/{{build_number}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/cap-builder' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_type="<Your_Device_Type>"' \
--form 'device_name="<Your_Device_Name>"' \
--form 'os_version="<Your_os_version>"' \
--form 'device_tag="<Tag_Name>"' \
--form 'manufactured_by="<Manufacturer_Name>"' \
--form 'project_name="<Project_Name>"'\
--form 'order_by="rand"'\

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/cap-builder")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['device_type', '<Your_Device_Type>'],['device_name', '<Your_Device_Name>'],['os_version', '<Your_os_version>'],['device_tag', '<Tag_Name>'],['manufactured_by', '<Manufacturer_Name>'],['project_name','<Project_Name>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/cap-builder"

payload = {'user_token': '<Your_User_Token>',
'device_type': '<Your_Device_Type>',
'device_name': '<Your_Device_Name>',
'os_version': '<Your_os_version>',
'device_tag': '<Tag_Name>',
'manufactured_by': '<Manufacturer_Name>',
'project_name': '<Project_Name>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'device_type',
'contents' => '<Your_Device_Type>'
],
[
'name' => 'device_name',
'contents' => '<Your_Device_Name>'
],
[
'name' => 'os_version',
'contents' => '<Your_os_version>'
],
[
'name' => 'device_tag',
'contents' => '<Tag_Name>'
],
[
'name' => 'manufactured_by',
'contents' => '<Manufacturer_Name>'
],
[
'name' => 'project_name',
'contents' => '<Project_Name>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/cap-builder');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("device_type","<Your_Device_Type>")
.addFormDataPart("device_name","<Your_Device_Name>")
.addFormDataPart("os_version","<Your_os_version>")
.addFormDataPart("device_tag","<Tag_Name>")
.addFormDataPart("manufactured_by","<Manufacturer_Name>")
.addFormDataPart("project_name","<Project_Name>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/cap-builder")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("device_type", "<Your_Device_Type>");
formdata.append("device_name", "<Your_Device_Name>");
formdata.append("os_version", "<Your_os_version>");
formdata.append("device_tag", "<Tag_Name>");
formdata.append("manufactured_by", "<Manufacturer_Name>");
formdata.append("project_name", "<Project_Name>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/cap-builder", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/cap-builder"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_type", "<Your_Device_Type>")
_ = writer.WriteField("device_name", "<Your_Device_Name>")
_ = writer.WriteField("os_version", "<Your_os_version>")
_ = writer.WriteField("device_tag", "<Tag_Name>")
_ = writer.WriteField("manufactured_by", "<Manufacturer_Name>")
_ = writer.WriteField("project_name", "<Project_Name>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/cap-builder");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Device_Type>"), "device_type");
content.Add(new StringContent("<Your_Device_Name>"), "device_name");
content.Add(new StringContent("<Your_os_version>"), "os_version");
content.Add(new StringContent("<Tag_Name>"), "device_tag");
content.Add(new StringContent("<Manufacturer_Name>"), "manufactured_by");
content.Add(new StringContent("<Project_Name>"), "project_name");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/releasedevice/{{device_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_id="<Your_Device_id>"' \
--form 'start_date_time="<Your_start_date_time>"' \
--form 'end_date_time="<Your_end_date_time>"' \
--form 'timezone="<Your_Time_Zone>"' \
--form 'comments="<Your_Comments>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['device_id', '<Your_Device_id>'],['start_date_time', '<Your_start_date_time>'],['end_date_time', '<Your_end_date_time>'],['timezone', '<Your_Time_Zone>'],['comments', '<Your_Comments>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/"

payload = {'user_token': '<Your_User_Token>',
'device_id': '<Your_Device_id>',
'start_date_time': '<Your_start_date_time>',
'end_date_time': '<Your_end_date_time>',
'timezone': '<Your_Time_Zone>',
'comments': '<Your_Comments>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_id>'
],
[
'name' => 'start_date_time',
'contents' => '<Your_start_date_time>'
],
[
'name' => 'end_date_time',
'contents' => '<Your_end_date_time>'
],
[
'name' => 'timezone',
'contents' => '<Your_Time_Zone>'
],
[
'name' => 'comments',
'contents' => '<Your_Comments>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("device_id","<Your_Device_id>")
.addFormDataPart("start_date_time","<Your_start_date_time>")
.addFormDataPart("end_date_time","<Your_end_date_time>")
.addFormDataPart("timezone","<Your_Time_Zone>")
.addFormDataPart("comments","<Your_Comments>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("device_id", "<Your_Device_id>");
formdata.append("start_date_time", "<Your_start_date_time>");
formdata.append("end_date_time", "<Your_end_date_time>");
formdata.append("timezone", "<Your_Time_Zone>");
formdata.append("comments", "<Your_Comments>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_id", "<Your_Device_id>")
_ = writer.WriteField("start_date_time", "<Your_start_date_time>")
_ = writer.WriteField("end_date_time", "<Your_end_date_time>")
_ = writer.WriteField("timezone", "<Your_Time_Zone>")
_ = writer.WriteField("comments", "<Your_Comments>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/reservedevice/{{user_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Device_id>"), "device_id");
content.Add(new StringContent("<Your_start_date_time>"), "start_date_time");
content.Add(new StringContent("<Your_end_date_time>"), "end_date_time");
content.Add(new StringContent("<Your_Time_Zone>"), "timezone");
content.Add(new StringContent("<Your_Comments>"), "comments");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/user/reservedevicelist' \
--form 'user_token="<Your_User_Token>"' \
--form 'timezone="<Your_Time_Zone>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/reservedevicelist")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['timezone', '<Your_Time_Zone>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/reservedevicelist"

payload = {'user_token': '<Your_User_Token>',
'timezone': '<Your_Time_Zone>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'timezone',
'contents' => '<Your_Time_Zone>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/reservedevicelist');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("timezone","")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/reservedevicelist")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("timezone", "<Your_Time_Zone>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/reservedevicelist", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/reservedevicelist"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("timezone", "<Your_Time_Zone>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/reservedevicelist");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Time_Zone>"), "timezone");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/user/releasereservedevice' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_reservation_id="<Device_Reservation_ID>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/releasereservedevice")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['device_reservation_id', '<Device_Reservation_ID>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/releasereservedevice"

payload = {'user_token': '<Your_User_Token>',
'device_reservation_id': '<Device_Reservation_ID>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'device_reservation_id',
'contents' => '<Device_Reservation_ID>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/releasereservedevice');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("device_reservation_id","<Device_Reservation_ID>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/releasereservedevice")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("device_reservation_id", "<Device_Reservation_ID>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/releasereservedevice", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/releasereservedevice"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_reservation_id", "<Device_Reservation_ID>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/releasereservedevice");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Device_Reservation_ID>"), "device_reservation_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/user/cancelreservedevice' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_reservation_id="<Your_device_reservation_id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/cancelreservedevice")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['device_reservation_id', '<Your_device_reservation_id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/cancelreservedevice"

payload = {'user_token': '<Your_User_Token>',
'device_reservation_id': '<Your_device_reservation_id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'device_reservation_id',
'contents' => '<Your_device_reservation_id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/cancelreservedevice');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("device_reservation_id","<Your_device_reservation_id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/cancelreservedevice")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("device_reservation_id", "<Your_device_reservation_id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/cancelreservedevice", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/cancelreservedevice"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_reservation_id", "<Your_device_reservation_id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/cancelreservedevice");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_device_reservation_id>"), "device_reservation_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}' \
--form 'user_token="<Your_User_Token>"' \
--form 'file=@"<Your_Uploaded_File>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['file', File.open('<Your_Uploaded_File>')]]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}"

payload = {'user_token': '<Your_User_Token>'}
files=[
('file',('<Your_Uploaded_File>',open('','rb'),'application/octet-stream'))
]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'file',
'contents' => Utils::tryFopen('', 'r'),
'filename' => '<Your_Uploaded_File>',
'headers' => [
'Content-Type' => ''
]
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("file","<Your_Uploaded_File>",
RequestBody.create(MediaType.parse("application/octet-stream"),
new File("<Your_Uploaded_File>")))
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("file", fileInput.files[0], "<Your_Uploaded_File>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"os"
"path/filepath"
"io"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/adb-file-upload/{device_id}"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
file, errFile2 := os.Open("<Your_Uploaded_File>")
defer file.Close()
part2,
errFile2 := writer.CreateFormFile("file",filepath.Base(""))
_, errFile2 = io.Copy(part2, file)
if errFile2 != nil {
fmt.Println(errFile2)
return
}
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/execute-shell-adb-native/1");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Uploaded_File>"), "command");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/execute-shell-adb-native/1' \
--form 'user_token="<Your_User_Token>"' \
--form 'command="<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/execute-shell-adb-native/1")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['command', '<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/execute-shell-adb-native/1"

payload = {'user_token': '<Your_User_Token>',
'command': '<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'command',
'contents' => '<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/execute-shell-adb-native/1');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("command","<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/execute-shell-adb-native/1")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("command", "<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/execute-shell-adb-native/1", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/execute-shell-adb-native/1"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("command", "<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/execute-shell-adb-native/1");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<pull /storage/emulated/0/Download/ABCD.jpg TGFileName=tgnewpull.png>"), "command");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}' \
--form 'user_token="<Your_User_Token>"' \
--form 'command="<your adb shell command>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['command', '<your adb shell command>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}"

payload = {'user_token': '<Your_User_Token>',
'command': '<your adb shell command>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'command',
'contents' => '<your adb shell command>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("command","<your adb shell command>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("command", "<your adb shell command>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("command", "<your adb shell command>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/execute-shell-adb-native/{device_id}");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<your adb shell command>"), "command");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/execute-shell-adb/3' \
--form 'user_token="<Your_User_Token>"' \
--form 'command="<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/execute-shell-adb/3")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['command', '<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/execute-shell-adb/3"

payload = {'user_token': '<Your_User_Token>',
'command': '<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'command',
'contents' => '<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/execute-shell-adb/3');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("command","<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/execute-shell-adb/3")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("command", "<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/execute-shell-adb/3", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/execute-shell-adb/3"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("command", "<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/execute-shell-adb/3");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<{\"command\":\"pm\",\"args\":[\"list\",\"users\",\"|\",\"grep\",\"New user\"]}>"), "command");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/installed-app/{{device_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/' \
--form 'user_token="<Your_User_Token>"' \
--form 'bundle_id="<Your_bundle_id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['bundle_id', '<Your_bundle_id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/"

payload = {'user_token': '<Your_User_Token>',
'bundle_id': '<Your_bundle_id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'bundle_id',
'contents' => '<Your_bundle_id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("bundle_id","<Your_bundle_id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("bundle_id", "<Your_bundle_id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("bundle_id", "<Your_bundle_id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/uninstall-app/{{device_id}}/");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_bundle_id>"), "bundle_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/devicecloud/api/restartDevice' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_id="<Your_Device_Id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/devicecloud/api/restartDevice")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['device_id', '<Your_Device_Id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/devicecloud/api/restartDevice"

payload = {'user_token': '<Your_User_Token>',
'device_id': '<Your_Device_Id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_Id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/devicecloud/api/restartDevice');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("device_id","<Your_Device_Id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/devicecloud/api/restartDevice")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("device_id", "<Your_Device_Id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/devicecloud/api/restartDevice", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/devicecloud/api/restartDevice"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_id", "<Your_Device_Id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/devicecloud/api/restartDevice");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Device_Id>"), "device_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities' \
--form 'user_token="<Your_User_Token>"' \
--form 'device_id="<Your_Device_Id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['device_id', '<Your_Device_Id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities"

payload = {'user_token': '<Your_User_Token>',
'device_id': '<Your_Device_Id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_Id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("device_id","<Your_Device_Id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("device_id", "<Your_Device_Id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("device_id", "<Your_Device_Id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/devicecloud/api/GetAppiumCapabilities");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Device_Id>"), "device_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/image-integration' \
--form 'user_token="<Your_User_Token>"' \
--form 'image="<Your_Image>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/image-integration")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['image', '<Your_Image>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/image-integration"

payload = {'user_token': '<Your_User_Token>',
'image': '<Your_Image>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'image',
'contents' => '<Your_Image>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/image-integration');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("image","<Your_Image>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/image-integration")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("image", "<Your_Image>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/image-integration", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/image-integration"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("image", "<Your_Image>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/image-integration");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Image>"), "image");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/clean-device/{device_id}' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/clean-device/{device_id}")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/clean-device/{device_id}"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/clean-device/{device_id}');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/clean-device/{device_id}")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/clean-device/{device_id}", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/clean-device/{device_id}"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/clean-device/{device_id}");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/free-system-port/{device_id}' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/free-system-port/{device_id}")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/free-system-port/{device_id}"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/free-system-port/{device_id}');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/free-system-port/{device_id}")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/free-system-port/{device_id}", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/free-system-port/{device_id}"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/free-system-port/{device_id}");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/get-device-analytics' \
--form 'user_token="<Your_User_Token>"' \
--form 'team_id="<Your_Team_Id>"' \
--form 'process_server="<Your_process_server>"' \
--form 'filter_date_from="<Your_filter_date_from>"' \
--form 'filter_date_to="<Your_filter_date_to>"' \
--form 'page="<Your_page>"' \
--form 'device_id="<Your_Device_Id>"' \
--form 'pageLimit="<Your_pageLimit>"' \
--form 'user_id="<Your_User_Id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/get-device-analytics")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '"<Your_User_Token>'],['team_id', '<Your_Team_Id>'],['process_server', '<Your_process_server>'],['filter_date_from', '<Your_filter_date_from>'],['filter_date_to', '<Your_filter_date_to>'],['page', '<Your_page>'],['device_id', '<Your_Device_Id>'],['pageLimit', '<Your_pageLimit>'],['user_id', '<Your_User_Id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/get-device-analytics"

payload = {'user_token': '<Your_User_Token>',
'team_id': '<Your_Team_Id>',
'process_server': '<Your_process_server>',
'filter_date_from': '<Your_filter_date_from>',
'filter_date_to': '<Your_filter_date_to>',
'page': '<Your_page>',
'device_id': '<Your_Device_Id>',
'pageLimit': '<Your_pageLimit>',
'user_id': '<Your_User_Id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'team_id',
'contents' => '<Your_Team_Id>'
],
[
'name' => 'process_server',
'contents' => '<Your_Process_Server>'
],
[
'name' => 'filter_date_from',
'contents' => '<Your_Filter_Date_From>'
],
[
'name' => 'filter_date_to',
'contents' => '<Your_Filter_Date_To>'
],
[
'name' => 'page',
'contents' => '<Your_Page>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_Id>'
],
[
'name' => 'pageLimit',
'contents' => '<Your_PageLimit>'
],
[
'name' => 'user_id',
'contents' => '<Your_User_Id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/get-device-analytics');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("team_id","<Your_Team_Id>")
.addFormDataPart("process_server","<Your_Process_Server>")
.addFormDataPart("filter_date_from","<Your_Filter_Date_From>")
.addFormDataPart("filter_date_to","<Your_Filter_Date_To>")
.addFormDataPart("page","<Your_Page>")
.addFormDataPart("device_id","<Your_Device_Id>")
.addFormDataPart("pageLimit","<Your_PageLimit>")
.addFormDataPart("user_id","<Your_User_Id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/get-device-analytics")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("team_id", "<Your_Team_Id>");
formdata.append("process_server", "<Your_Process_Server>");
formdata.append("filter_date_from", "<Your_Filter_Date_From>");
formdata.append("filter_date_to", "<Your_Filter_Date_To>");
formdata.append("page", "<Your_Page>");
formdata.append("device_id", "<Your_Device_Id>");
formdata.append("pageLimit", "<Your_pageLimit>");
formdata.append("user_id", "<Your_User_Id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/get-device-analytics", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/get-device-analytics"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("team_id", "<Your_Team_Id>")
_ = writer.WriteField("process_server", "<Your_Process_Server>")
_ = writer.WriteField("filter_date_from", "<Your_Filter_Date_From>")
_ = writer.WriteField("filter_date_to", "<Your_Filter_Date_To>")
_ = writer.WriteField("page", "<Your_Page>")
_ = writer.WriteField("device_id", "<Your_Device_Id>")
_ = writer.WriteField("pageLimit", "<Your_PageLimit>")
_ = writer.WriteField("user_id", "<Your_User_Id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/get-device-analytics");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Team_Id>"), "team_id");
content.Add(new StringContent("<Your_Process_Server>"), "process_server");
content.Add(new StringContent("<Your_Filter_Date_From>"), "filter_date_from");
content.Add(new StringContent("<Your_Filter_Date_To>"), "filter_date_to");
content.Add(new StringContent("<Your_Page>"), "page");
content.Add(new StringContent("<Your_Device_Id>"), "device_id");
content.Add(new StringContent("<Your_PageLimit>"), "pageLimit");
content.Add(new StringContent("<Your_User_Id>"), "user_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location --globoff 'https://your_domain.testgrid.io/api/user/downloads/{device_id}' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/user/downloads/{device_id}")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/user/downloads/{device_id}"

payload = {'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/user/downloads/{device_id}');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/user/downloads/{device_id}")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/user/downloads/{device_id}", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/user/downloads/{device_id}"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/user/downloads/{device_id}");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/set-pin-api' \
--form 'device_id="<Your_Device_ID>"' \
--form 'pin="<Your_pin>"' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/set-pin-api")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['device_id', '<Your_Device_ID>'],['pin', '<Your_pin>'],['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/set-pin-api"

payload = {'device_id': '<Your_Device_ID>',
'pin': '<Your_pin>',
'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'device_id',
'contents' => '<Your_Device_ID>'
],
[
'name' => 'pin',
'contents' => '<Your_pin>'
],
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/set-pin-api');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("device_id","<Your_Device_ID>")
.addFormDataPart("pin","<Your_pin>")
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/set-pin-api")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("device_id", "<Your_Device_ID>");
formdata.append("pin", "<Your_pin>");
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/set-pin-api", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/set-pin-api"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("device_id", "<Your_Device_ID>")
_ = writer.WriteField("pin", "<Your_pin>")
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/set-pin-api");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_Device_ID>"), "device_id");
content.Add(new StringContent("<Your_pin>"), "pin");
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/remove-pin-api' \
--form 'pin="<Your_pin>"' \
--form 'device_id="<Your_Device_ID>"' \
--form 'user_token="<Your_User_Token>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/remove-pin-api")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['pin', '<Your_pin>'],['device_id', '<Your_Device_ID>'],['user_token', '<Your_User_Token>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/remove-pin-api"

payload = {'pin': '<Your_pin>',
'device_id': '<Your_Device_ID>',
'user_token': '<Your_User_Token>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'pin',
'contents' => '<Your_pin>'
],
[
'name' => 'device_id',
'contents' => '<Your_Device_ID>'
],
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/remove-pin-api');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("pin","<Your_pin>")
.addFormDataPart("device_id","<Your_Device_ID>")
.addFormDataPart("user_token","<Your_User_Token>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/remove-pin-api")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("pin", "<Your_pin>");
formdata.append("device_id", "<Your_Device_ID>");
formdata.append("user_token", "<Your_User_Token>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/remove-pin-api", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/remove-pin-api"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("pin", "<Your_pin>")
_ = writer.WriteField("device_id", "<Your_Device_ID>")
_ = writer.WriteField("user_token", "<Your_User_Token>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/remove-pin-api");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_pin>"), "pin");
content.Add(new StringContent("<Your_Device_ID>"), "device_id");
content.Add(new StringContent("<Your_User_Token>"), "user_token");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/change-pin-api' \
--form 'device_id="<Your_Device_ID>"' \
--form 'user_token="<Your_User_Token>"' \
--form 'old_pin="<Your_old_pin>"' \
--form 'new_pin="<Your_new_pin>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/change-pin-api")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['device_id', '<Your_Device_ID>'],['user_token', '<Your_User_Token>'],['old_pin', '<Your_old_pin>'],['new_pin', '<Your_new_pin>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/change-pin-api"

payload = {'device_id': '<Your_Device_ID>',
'user_token': '<Your_User_Token>',
'old_pin': '<Your_old_pin>',
'new_pin': '<Your_new_pin>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'device_id',
'contents' => '<Your_Device_ID>'
],
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'old_pin',
'contents' => '<Your_old_pin>'
],
[
'name' => 'new_pin',
'contents' => '<Your_new_pin>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/change-pin-api');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("device_id","<Your_Device_ID>")
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("old_pin","<Your_old_pin>")
.addFormDataPart("new_pin","<Your_new_pin>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/change-pin-api")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("device_id", "<Your_Device_ID>");
formdata.append("user_token", "<Your_User_Token>");
formdata.append("old_pin", "<Your_old_pin>");
formdata.append("new_pin", "<Your_new_pin>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/change-pin-api", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/change-pin-api"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("device_id", "<Your_Device_ID>")
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("old_pin", "<Your_old_pin>")
_ = writer.WriteField("new_pin", "<Your_new_pin>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/change-pin-api");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_Device_ID>"), "device_id");
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_old_pin>"), "old_pin");
content.Add(new StringContent("<Your_new_pin>"), "new_pin");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/unlock-device-api' \
--form 'device_id="<Your_Device_ID>"' \
--form 'user_token="<Your_User_Token>"' \
--form 'pin="<Your_PIN>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/api/unlock-device-api")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['device_id', '<Your_Device_ID>'],['user_token', '<Your_User_Token>'],['pin', '<Your_PIN>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/api/unlock-device-api"

payload = {'device_id': '<Your_Device_ID>',
'user_token': '<Your_User_Token>',
'pin': '<Your_PIN>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'device_id',
'contents' => '<Your_Device_ID>'
],
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'pin',
'contents' => '<Your_PIN>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/api/unlock-device-api');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("device_id","<Your_Device_ID>")
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("pin","<Your_PIN>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/api/unlock-device-api")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("device_id", "<Your_Device_ID>");
formdata.append("user_token", "<Your_User_Token>");
formdata.append("pin", "<Your_PIN>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/api/unlock-device-api", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/api/unlock-device-api"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("device_id", "<Your_Device_ID>")
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("pin", "<Your_PIN>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/api/unlock-device-api");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_Device_ID>"), "device_id");
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_PIN>"), "pin");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/testcase_detail' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'build_test_id="<Your_Build_Test_id>"' \
--form 'test_case_name="<Your_Test_Case_Name>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/testcase_detail")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['build_test_id', '<Your_Build_Test_id>'],['test_case_name', '<Your_Test_Case_Name>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/testcase_detail"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'build_test_id': '<Your_Build_Test_id>',
'test_case_name': '<Your_Test_Case_Name>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'build_test_id',
'contents' => '<Your_Build_Test_id>'
],
[
'name' => 'test_case_name',
'contents' => '<Your_Test_Case_Name>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/testcase_detail');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("build_test_id","<Your_Build_Test_id>")
.addFormDataPart("test_case_name","<Your_Test_Case_Name>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/testcase_detail")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("build_test_id", "<Your_Build_Test_id>");
formdata.append("test_case_name", "<Your_Test_Case_Name>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/testcase_detail", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/testcase_detail"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("build_test_id", "<Your_Build_Test_id>")
_ = writer.WriteField("test_case_name", "<Your_Test_Case_Name>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/testcase_detail");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_Build_Test_id>"), "build_test_id");
content.Add(new StringContent("<Your_Test_Case_Name>"), "test_case_name");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/build_list' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_token>"' \
--form 'build_number="<Your_build_number>"' \
--form 'last_minutes="<Your_Last_Minutes>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/build_list")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_token>'],['build_number', '<Your_build_number>'],['last_minutes', '<Your_Last_Minutes>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/build_list"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_token>',
'build_number': '<Your_build_number>',
'last_minutes': '<Your_Last_Minutes>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_token>'
],
[
'name' => 'build_number',
'contents' => '<Your_build_number>'
],
[
'name' => 'last_minutes',
'contents' => '<Your_Last_Minutes>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/build_list');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_token>")
.addFormDataPart("build_number","<Your_build_number>")
.addFormDataPart("last_minutes","<Your_Last_Minutes>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/build_list")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_token>");
formdata.append("build_number", "<Your_build_number>");
formdata.append("last_minutes", "<Your_Last_Minutes>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/build_list", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/build_list"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_token>")
_ = writer.WriteField("build_number", "<Your_build_number>")
_ = writer.WriteField("last_minutes", "<Your_Last_Minutes>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/build_list");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_token>"), "application_token");
content.Add(new StringContent("<Your_build_number>"), "build_number");
content.Add(new StringContent("<Your_Last_Minutes>"), "last_minutes");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/update_variable_value' \
--form 'user_token="<Your_User_Token>"' \
--form 'version_token="<Your_Version_Token>"' \
--form 'test_case_name="<Your_Test_Case_name>"' \
--form 'var_name="<Your_Var_Name>"' \
--form 'var_value="<Your_Var_Value>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/update_variable_value")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['version_token', '<Your_Version_Token>'],['test_case_name', '<Your_Test_Case_name>'],['var_name', '<Your_Var_Name>'],['var_value', '<Your_Var_Value>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/update_variable_value"

payload = {'user_token': '<Your_User_Token>',
'version_token': '<Your_Version_Token>',
'test_case_name': '<Your_Test_Case_name>',
'var_name': '<Your_Var_Name>',
'var_value': '<Your_Var_Value>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'version_token',
'contents' => '<Your_Version_Token>'
],
[
'name' => 'test_case_name',
'contents' => '<Your_Test_Case_name>'
],
[
'name' => 'var_name',
'contents' => '<Your_Var_Name>'
],
[
'name' => 'var_value',
'contents' => '<Your_Var_Value>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/update_variable_value');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("version_token","<Your_Version_Token>")
.addFormDataPart("test_case_name","<Your_Test_Case_name>")
.addFormDataPart("var_name","<Your_Var_Name>")
.addFormDataPart("var_value","<Your_Var_Value>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/update_variable_value")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("version_token", "<Your_Version_Token>");
formdata.append("test_case_name", "<Your_Test_Case_name>");
formdata.append("var_name", "<Your_Var_Name>");
formdata.append("var_value", "<Your_Var_Value>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/update_variable_value", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/update_variable_value"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("version_token", "<Your_Version_Token>")
_ = writer.WriteField("test_case_name", "<Your_Test_Case_name>")
_ = writer.WriteField("var_name", "<Your_Var_Name>")
_ = writer.WriteField("var_value", "<Your_Var_Value>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/update_variable_value");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Version_Token>"), "version_token");
content.Add(new StringContent("<Your_Test_Case_name>"), "test_case_name");
content.Add(new StringContent("<Your_Var_Name>"), "var_name");
content.Add(new StringContent("<Your_Var_Value>"), "var_value");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/execution_detail' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_token>"' \
--form 'build_number="<Your_build_number>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/execution_detail")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_token>'],['build_number', '<Your_build_number>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/execution_detail"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_token>',
'build_number': '<Your_build_number>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_token>'
],
[
'name' => 'build_number',
'contents' => '<Your_build_number>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/execution_detail');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_token>")
.addFormDataPart("build_number","<Your_build_number>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/execution_detail")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_token>");
formdata.append("build_number", "<Your_build_number>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/execution_detail", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/execution_detail"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_token>")
_ = writer.WriteField("build_number", "<Your_build_number>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/execution_detail");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_token>"), "application_token");
content.Add(new StringContent("<Your_build_number>"), "build_number");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/networklog' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_token>"' \
--form 'build_test_id="<Your_build_test_id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/networklog")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_token>'],['build_test_id', '<Your_build_test_id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/networklog"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_token>',
'build_test_id': '<Your_build_test_id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_token>'
],
[
'name' => 'build_test_id',
'contents' => '<Your_build_test_id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/networklog');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_token>")
.addFormDataPart("build_test_id","<Your_build_test_id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/networklog")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_token>");
formdata.append("build_test_id", "<Your_build_test_id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/networklog", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/networklog"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_token>")
_ = writer.WriteField("build_test_id", "<Your_build_test_id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/networklog");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_token>"), "application_token");
content.Add(new StringContent("<Your_build_test_id>"), "build_test_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/Insights' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'build_test_id="<Your_build_test_id>"' \
--form 'test_case_name="<Your_test_case_name>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/Insights")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['build_test_id', '<Your_build_test_id>'],['test_case_name', '<Your_test_case_name>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/Insights"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'build_test_id': '<Your_build_test_id>',
'test_case_name': '<Your_test_case_name>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'build_test_id',
'contents' => '<Your_build_test_id>'
],
[
'name' => 'test_case_name',
'contents' => '<Your_test_case_name>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/Insights');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("build_test_id","<Your_build_test_id>")
.addFormDataPart("test_case_name","<Your_test_case_name>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/Insights")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("build_test_id", "<Your_build_test_id>");
formdata.append("test_case_name", "<Your_test_case_name>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/Insights", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/Insights"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("build_test_id", "<Your_build_test_id>")
_ = writer.WriteField("test_case_name", "<Your_test_case_name>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/Insights");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_build_test_id>"), "build_test_id");
content.Add(new StringContent("<Your_test_case_name>"), "test_case_name");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/transaction_analysis' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'build_test_id="<Your_build_test_id>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/transaction_analysis")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['build_test_id', '<Your_build_test_id>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/transaction_analysis"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'build_test_id': '<Your_build_test_id>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'build_test_id',
'contents' => '<Your_build_test_id>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/transaction_analysis');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("build_test_id","<Your_build_test_id>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/transaction_analysis")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("build_test_id", "<Your_build_test_id>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/transaction_analysis", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/transaction_analysis"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("build_test_id", "<Your_build_test_id>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/transaction_analysis");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_build_test_id>"), "build_test_id");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/execution_detail_by_tags' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'tags="<Your_Tags>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/execution_detail_by_tags")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['tags', '<Your_Tags>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/execution_detail_by_tags"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'tags': '<Your_Tags>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'tags',
'contents' => '<Your_Tags>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/execution_detail_by_tags');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("tags","<Your_Tags>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/execution_detail_by_tags")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("tags", "<Your_Tags>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/execution_detail_by_tags", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/execution_detail_by_tags"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("tags", "<Your_Tags>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/execution_detail_by_tags");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_Tags>"), "tags");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/app_build_run' \
--form 'user_token="<Your_User_Token>"' \
--form 'application_token="<Your_Application_Token>"' \
--form 'version_token="<Your_Version_Token>"' \
--form 'version_module_id="<Your_Version_module>"' \
--form 's_device="<Your_s_device>"' \
--form 'process_type="<Your_Process_Type>"' \
--form 'app_build_id="<Your_App_Build_id>"' \
--form 'bundle_identifier="<Your_bundle_identifier>"' \
--form 'test_website_url="<The URL of the website to be tested during the app build run>"' \
--form 'is_launch_with_tgconnect="<To execute your test cases by securely connecting your local machine to Test Grid devices>"' \
--form 'selected_testcase_id="<Test case Ids for the Test we like to execute>"' \
--form 'is_resign_ios_ipa="<Set to 1 to enable iOS IPA resigning during IPA Installation>"' \
--form 'tags="<Tags assigned for the Test cases we like to execute>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/app_build_run")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['user_token', '<Your_User_Token>'],['application_token', '<Your_Application_Token>'],['version_token', '<Your_Version_Token>'],['version_module_id', '<Your_Version_module>'],['s_device', '<Your_s_device>'],['process_type', '<Your_Process_Type>'],['app_build_id', '<Your_App_Build_id>'],['bundle_identifier', '<Your_bundle_identifier>'],['test_website_url', '<Tags assigned for the Test cases we like to execute>'],['selected_testcase_id', '<Test case Ids for the Test we like to execute>'],['tags', '<Tags assigned for the Test cases we like to execute>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/app_build_run"

payload = {'user_token': '<Your_User_Token>',
'application_token': '<Your_Application_Token>',
'version_token': '<Your_Version_Token>',
'version_module_id': '<Your_Version_module>',
's_device': '<Your_s_device>',
'process_type': '<Your_Process_Type>',
'app_build_id': '<Your_App_Build_id>',
'bundle_identifier': '<Your_bundle_identifier>',
'test_website_url': '<The URL of the website to be tested during the app build run>',
'selected_testcase_id': '<Test case Ids for the Test we like to execute>',
'tags': '<Tags assigned for the Test cases we like to execute>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'user_token',
'contents' => '<Your_User_Token>'
],
[
'name' => 'application_token',
'contents' => '<Your_Application_Token>'
],
[
'name' => 'version_token',
'contents' => '<Your_Version_Token>'
],
[
'name' => 'version_module_id',
'contents' => '<Your_Version_module>'
],
[
'name' => 's_device',
'contents' => '<Your_s_device>'
],
[
'name' => 'process_type',
'contents' => '<Your_Process_Type>'
],
[
'name' => 'app_build_id',
'contents' => '<Your_App_Build_id>'
],
[
'name' => 'bundle_identifier',
'contents' => '<Your_bundle_identifier>'
],
[
'name' => 'test_website_url',
'contents' => '<The URL of the website to be tested during the app build run>'
],
[
'name' => 'selected_testcase_id',
'contents' => '<Test case Ids for the Test we like to execute>'
],
[
'name' => 'tags',
'contents' => '<Tags assigned for the Test cases we like to execute>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/app_build_run');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("user_token","<Your_User_Token>")
.addFormDataPart("application_token","<Your_Application_Token>")
.addFormDataPart("version_token","<Your_Version_Token>")
.addFormDataPart("version_module_id","<Your_Version_module>")
.addFormDataPart("s_device","<Your_s_device>")
.addFormDataPart("process_type","<Your_Process_Type>")
.addFormDataPart("app_build_id","<Your_App_Build_id>")
.addFormDataPart("bundle_identifier","<Your_bundle_identifier>")
.addFormDataPart("test_website_url","<The URL of the website to be tested during the app build run>")
.addFormDataPart("selected_testcase_id","<Test case Ids for the Test we like to execute>")
.addFormDataPart("tags","<Tags assigned for the Test cases we like to execute>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/app_build_run")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("user_token", "<Your_User_Token>");
formdata.append("application_token", "<Your_Application_Token>");
formdata.append("version_token", "<Your_Version_Token>");
formdata.append("version_module_id", "<Your_Version_module>");
formdata.append("s_device", "<Your_s_device>");
formdata.append("process_type", "<Your_Process_Type>");
formdata.append("app_build_id", "<Your_App_Build_id>");
formdata.append("bundle_identifier", "<Your_bundle_identifier>");
formdata.append("test_website_url", "<The URL of the website to be tested during the app build run>");
formdata.append("selected_testcase_id", "<Test case Ids for the Test we like to execute>");
formdata.append("tags", "<Tags assigned for the Test cases we like to execute>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/app_build_run", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/app_build_run"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("user_token", "<Your_User_Token>")
_ = writer.WriteField("application_token", "<Your_Application_Token>")
_ = writer.WriteField("version_token", "<Your_Version_Token>")
_ = writer.WriteField("version_module_id", "<Your_Version_module>")
_ = writer.WriteField("s_device", "<Your_s_device>")
_ = writer.WriteField("process_type", "<Your_Process_Type>")
_ = writer.WriteField("app_build_id", "<Your_App_Build_id>")
_ = writer.WriteField("bundle_identifier", "<Your_bundle_identifier>")
_ = writer.WriteField("test_website_url", "<The URL of the website to be tested during the app build run>")
_ = writer.WriteField("selected_testcase_id", "<Test case Ids for the Test we like to execute>")
_ = writer.WriteField("tags", "<Tags assigned for the Test cases we like to execute>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/app_build_run");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_User_Token>"), "user_token");
content.Add(new StringContent("<Your_Application_Token>"), "application_token");
content.Add(new StringContent("<Your_Version_Token>"), "version_token");
content.Add(new StringContent("<Your_Version_module>"), "version_module_id");
content.Add(new StringContent("<Your_s_device>"), "s_device");
content.Add(new StringContent("<Your_Process_Type>"), "process_type");
content.Add(new StringContent("<Your_App_Build_id>"), "app_build_id");
content.Add(new StringContent("<Your_bundle_identifier>"), "bundle_identifier");
content.Add(new StringContent("<The URL of the website to be tested during the app build run>"), "test_website_url");
content.Add(new StringContent("<Test case Ids for the Test we like to execute>"), "selected_testcase_id");
content.Add(new StringContent("<Tags assigned for the Test cases we like to execute>"), "tags");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/json_upload' \
--form 'json_content="<Your_json_content>"' \
--form 'existing_file="<Your_existing_file>"' \
--form 'upload_file="<Your_upload_file>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/json_upload")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['json_content', '<Your_json_content>'],['existing_file', '<Your_existing_file>'],['upload_file', '<Your_upload_file>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/json_upload"

payload = {'json_content': '<Your_json_content>',
'existing_file': '<Your_existing_file>',
'upload_file': '<Your_upload_file>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'json_content',
'contents' => '<Your_json_content>'
],
[
'name' => 'existing_file',
'contents' => '<Your_existing_file>'
],
[
'name' => 'upload_file',
'contents' => '<Your_upload_file>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/json_upload');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("json_content","<Your_json_content>")
.addFormDataPart("existing_file","<Your_existing_file>")
.addFormDataPart("upload_file","<Your_upload_file>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/json_upload")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("json_content", "<Your_json_content>");
formdata.append("existing_file", "<Your_existing_file>");
formdata.append("upload_file", "<Your_upload_file>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/json_upload", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/json_upload"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("json_content", "<Your_json_content>")
_ = writer.WriteField("existing_file", "<Your_existing_file>")
_ = writer.WriteField("upload_file", "<Your_upload_file>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/json_upload");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_json_content>"), "json_content");
content.Add(new StringContent("<Your_existing_file>"), "existing_file");
content.Add(new StringContent("<Your_upload_file>"), "upload_file");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/ci/csv_to_json' \
--form 'csv_content="<Your_csv_content>"' \
--form 'existing_file="<Your_existing_file>"' \
--form 'upload_file="<Your_upload_file>"'

require "uri"
require "net/http"

url = URI("https://your_domain.testgrid.io/ci/csv_to_json")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
form_data = [['csv_content', '<Your_csv_content>'],['existing_file', '<Your_existing_file>'],['upload_file', '<Your_upload_file>']]
request.set_form form_data, 'multipart/form-data'
response = https.request(request)
puts response.read_body

import requests

url = "https://your_domain.testgrid.io/ci/csv_to_json"

payload = {'csv_content': '<Your_csv_content>',
'existing_file': '<Your_existing_file>',
'upload_file': '<Your_upload_file>'}
files=[

]
headers = {}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)

<?php
$client = new Client();
$options = [
'multipart' => [
[
'name' => 'csv_content',
'contents' => '<Your_csv_content>'
],
[
'name' => 'existing_file',
'contents' => '<Your_existing_file>'
],
[
'name' => 'upload_file',
'contents' => '<Your_upload_file>'
]
]];
$request = new Request('POST', 'https://your_domain.testgrid.io/ci/csv_to_json');
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();

OkHttpClient client = new OkHttpClient().newBuilder()
.build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
.addFormDataPart("csv_content","<Your_csv_content>")
.addFormDataPart("existing_file","<Your_existing_file>")
.addFormDataPart("upload_file","<Your_upload_file>")
.build();
Request request = new Request.Builder()
.url("https://your_domain.testgrid.io/ci/csv_to_json")
.method("POST", body)
.build();
Response response = client.newCall(request).execute();

var formdata = new FormData();
formdata.append("csv_content", "<Your_csv_content>");
formdata.append("existing_file", "<Your_existing_file>");
formdata.append("upload_file", "<Your_upload_file>");

var requestOptions = {
method: 'POST',
body: formdata,
redirect: 'follow'
};

fetch("https://your_domain.testgrid.io/ci/csv_to_json", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));

package main

import (
"fmt"
"bytes"
"mime/multipart"
"net/http"
"io/ioutil"
)

func main() {

url := "https://your_domain.testgrid.io/ci/csv_to_json"
method := "POST"

payload := &bytes.Buffer{}
writer := multipart.NewWriter(payload)
_ = writer.WriteField("csv_content", "<Your_csv_content>")
_ = writer.WriteField("existing_file", "<Your_existing_file>")
_ = writer.WriteField("upload_file", "<Your_upload_file>")
err := writer.Close()
if err != nil {
fmt.Println(err)
return
}

client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)

if err != nil {
fmt.Println(err)
return
}
req.Header.Set("Content-Type", writer.FormDataContentType())
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://your_domain.testgrid.io/ci/csv_to_json");
var content = new MultipartFormDataContent();
content.Add(new StringContent("<Your_csv_content>"), "csv_content");
content.Add(new StringContent("<Your_existing_file>"), "existing_file");
content.Add(new StringContent("<Your_upload_file>"), "upload_file");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

curl --location 'https://your_domain.testgrid.io/api/tg-connect/{{device_id}}' \
--form 'user_token="{{user_token}}"' \
--form 'active="1"'