hallo

Auth

Base URL
https://api.infinitemlmsoftware.com

/get-company-logo

Header Parameters
Acceptstring
api-keystring

login

Header Parameters
Acceptstring
api-keystring

logOut

Header Parameters
api-keystring
access-tokenstring
Acceptstring
POST/auth/logout
curl --location --request POST 'https://api.infinitemlmsoftware.com/auth/logout' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/logout") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/auth/logout" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Accept': 'application/json', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json', 'Content-Type' => 'application/json' ]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/auth/logout', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/logout") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'POST', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/logout", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/auth/logout" method := "POST" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/auth/logout"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/auth/back-to-backoffice

Header Parameters
api-keystring
access-tokenstring
Acceptstring
stringstring
POST/auth/back-to-backoffice
curl --location --request POST 'https://api.infinitemlmsoftware.com/auth/back-to-backoffice' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json' \ --header 'string: 08ba2101-ead5-417d-8c7c-b978ade77aa1'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/back-to-backoffice") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" request["string"] = "08ba2101-ead5-417d-8c7c-b978ade77aa1" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/auth/back-to-backoffice" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Accept': 'application/json', 'string': '08ba2101-ead5-417d-8c7c-b978ade77aa1' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json', 'string' => '08ba2101-ead5-417d-8c7c-b978ade77aa1' ]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/auth/back-to-backoffice', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/logout") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'POST', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/logout", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/auth/logout" method := "POST" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/auth/logout"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

forgot-password

Header Parameters
api-keystring
Acceptstring
Body Parameters
usernamestring
POSTforgot-password
curl --location 'https://api.infinitemlmsoftware.com/auth/forgot-password' \ --header 'Accept: application/json' \ --header 'api-key: 08ba2101-ead5-417d-8c7c-b978ade77aa1' \ --header 'Content-Type: application/json' \ --data '{ "username": "tester2" }'
19 20 require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/forgot-password") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["api-key"] = "08ba2101-ead5-417d-8c7c-b978ade77aa1" request["Content-Type"] = "application/json" request.body = JSON.dump({ "username": "tester2" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/auth/forgot-password" payload = json.dumps({ "username": "tester2" }) headers = { 'Accept': 'application/json', 'api-key': '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'Content-Type' => 'application/json' ]; $body = '{ "username": "tester2" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/auth/forgot-password', $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, "{ \"username\": \"tester2\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/forgot-password") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "username": "tester2" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/forgot-password", 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://api.infinitemlmsoftware.com/auth/forgot-password" method := "POST" payload := strings.NewReader(`{ "username": "tester2" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/auth/forgot-password"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); var content = new StringContent("{ \"username\": \"tester2\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/verify-forgot-password

Header Parameters
api-keystring
access-tokenstring
Acceptstring
Query Parameters
hashstring
POST/verify-forgot-password
curl --location --request POST 'https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628' \ --header 'api-key: 08ba2101-ead5-417d-8c7c-b978ade77aa1' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "08ba2101-ead5-417d-8c7c-b978ade77aa1" request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628" payload = {} headers = { 'api-key': '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'access-token': '{{TOKEN}}', 'Accept': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json' ]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628") .method("POST", body) .addHeader("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); var requestOptions = { method: 'POST', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628" method := "POST" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") 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://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628"); request.Headers.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update-password

Header Parameters
api-keystring
access-tokenstring
Acceptstring
Body Parameters
passwordstring
hashstring
POST/update-password
curl --location 'https://api.infinitemlmsoftware.com/auth/update-password' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json' \ --header 'api-key: 08ba2101-ead5-417d-8c7c-b978ade77aa1' \ --header 'Content-Type: application/json' \ --data '{ "password": "12345678", "hash": "ikgbwsdefwsedobhwdsjfr" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/update-password") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = ["{{API_KEY}}", "08ba2101-ead5-417d-8c7c-b978ade77aa1"] request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" request["Content-Type"] = "application/json" request.body = JSON.dump({ "password": "12345678", "hash": "ikgbwsdefwsedobhwdsjfr" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/auth/update-password" payload = json.dumps({ "password": "12345678", "hash": "ikgbwsdefwsedobhwdsjfr" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Accept': 'application/json', 'api-key': '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}, 08ba2101-ead5-417d-8c7c-b978ade77aa1', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json', 'Content-Type' => 'application/json' ]; $body = '{ "password": "12345678", "hash": "ikgbwsdefwsedobhwdsjfr" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/auth/update-password', $headers, $body); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/verify-forgot-password?hash=dd9e8ee162cceddae81c0ab6d3da4628") .method("POST", body) .addHeader("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "password": "12345678", "hash": "ikgbwsdefwsedobhwdsjfr" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/update-password", 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://api.infinitemlmsoftware.com/auth/update-password" method := "POST" payload := strings.NewReader(`{ "password": "12345678", "hash": "ikgbwsdefwsedobhwdsjfr" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/auth/update-password"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); var content = new StringContent("{ \"password\": \"12345678\", \"hash\": \"ikgbwsdefwsedobhwdsjfr\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/auth/paypal-webhook

Header Parameters
api-keystring
access-tokenstring
Acceptstring
stringstring
Body Parameters
idstring
event_versionstring
create_timestring
resource_typestring
resource_versionstring
event_typestring
summarystring
resourceobject
start_timestring
quantitystring
create_timestring
linksarray
hrefstring
relstring
methodstring
idstring
plan_overriddenboolean
plan_idstring
statusstring
resourceobject
hrefstring
relstring
methodstring
POST/auth/paypal-webhook
curl --location 'https://api.infinitemlmsoftware.com/auth/paypal-webhook' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json' \ --header 'string: 08ba2101-ead5-417d-8c7c-b978ade77aa1' \ --header 'Content-Type: application/json' \ --data '{ "id": "WH-94D876612G9263632-38K706545B7995038", "event_version": "1.0", "create_time": "2024-06-12T11:35:58.798Z", "resource_type": "subscription", "resource_version": "2.0", "event_type": "BILLING.SUBSCRIPTION.CREATED", "summary": "Subscription created", "resource": { "start_time": "2024-06-13T11:35:51Z", "quantity": "1", "create_time": "2024-06-12T11:35:58Z", "links": [ { "href": "https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S", "rel": "approve", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "edit", "method": "PATCH" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "self", "method": "GET" } ], "id": "I-UGRJ500PGTB2", "plan_overridden": false, "plan_id": "P-26L6297332438632CMZUYP2Y", "status": "APPROVAL_PENDING" }, "links": [ { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038", "rel": "self", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend", "rel": "resend", "method": "POST" } ] }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/paypal-webhook") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" request["string"] = "08ba2101-ead5-417d-8c7c-b978ade77aa1" request["Content-Type"] = "application/json" request.body = JSON.dump({ "id": "WH-94D876612G9263632-38K706545B7995038", "event_version": "1.0", "create_time": "2024-06-12T11:35:58.798Z", "resource_type": "subscription", "resource_version": "2.0", "event_type": "BILLING.SUBSCRIPTION.CREATED", "summary": "Subscription created", "resource": { "start_time": "2024-06-13T11:35:51Z", "quantity": "1", "create_time": "2024-06-12T11:35:58Z", "links": [ { "href": "https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S", "rel": "approve", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "edit", "method": "PATCH" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "self", "method": "GET" } ], "id": "I-UGRJ500PGTB2", "plan_overridden": false, "plan_id": "P-26L6297332438632CMZUYP2Y", "status": "APPROVAL_PENDING" }, "links": [ { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038", "rel": "self", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend", "rel": "resend", "method": "POST" } ] }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/auth/paypal-webhook" payload = json.dumps({ "id": "WH-94D876612G9263632-38K706545B7995038", "event_version": "1.0", "create_time": "2024-06-12T11:35:58.798Z", "resource_type": "subscription", "resource_version": "2.0", "event_type": "BILLING.SUBSCRIPTION.CREATED", "summary": "Subscription created", "resource": { "start_time": "2024-06-13T11:35:51Z", "quantity": "1", "create_time": "2024-06-12T11:35:58Z", "links": [ { "href": "https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S", "rel": "approve", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "edit", "method": "PATCH" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "self", "method": "GET" } ], "id": "I-UGRJ500PGTB2", "plan_overridden": False, "plan_id": "P-26L6297332438632CMZUYP2Y", "status": "APPROVAL_PENDING" }, "links": [ { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038", "rel": "self", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend", "rel": "resend", "method": "POST" } ] }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Accept': 'application/json', 'string': '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json', 'string' => '08ba2101-ead5-417d-8c7c-b978ade77aa1', 'Content-Type' => 'application/json' ]; $body = '{ "id": "WH-94D876612G9263632-38K706545B7995038", "event_version": "1.0", "create_time": "2024-06-12T11:35:58.798Z", "resource_type": "subscription", "resource_version": "2.0", "event_type": "BILLING.SUBSCRIPTION.CREATED", "summary": "Subscription created", "resource": { "start_time": "2024-06-13T11:35:51Z", "quantity": "1", "create_time": "2024-06-12T11:35:58Z", "links": [ { "href": "https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S", "rel": "approve", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "edit", "method": "PATCH" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "self", "method": "GET" } ], "id": "I-UGRJ500PGTB2", "plan_overridden": false, "plan_id": "P-26L6297332438632CMZUYP2Y", "status": "APPROVAL_PENDING" }, "links": [ { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038", "rel": "self", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend", "rel": "resend", "method": "POST" } ] }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/auth/paypal-webhook', $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, "{ \"id\": \"WH-94D876612G9263632-38K706545B7995038\", \"event_version\": \"1.0\", \"create_time\": \"2024-06-12T11:35:58.798Z\", \"resource_type\": \"subscription\", \"resource_version\": \"2.0\", \"event_type\": \"BILLING.SUBSCRIPTION.CREATED\", \"summary\": \"Subscription created\", \"resource\": { \"start_time\": \"2024-06-13T11:35:51Z\", \"quantity\": \"1\", \"create_time\": \"2024-06-12T11:35:58Z\", \"links\": [ { \"href\": \"https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S\", \"rel\": \"approve\", \"method\": \"GET\" }, { \"href\": \"https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2\", \"rel\": \"edit\", \"method\": \"PATCH\" }, { \"href\": \"https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2\", \"rel\": \"self\", \"method\": \"GET\" } ], \"id\": \"I-UGRJ500PGTB2\", \"plan_overridden\": false, \"plan_id\": \"P-26L6297332438632CMZUYP2Y\", \"status\": \"APPROVAL_PENDING\" }, \"links\": [ { \"href\": \"https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038\", \"rel\": \"self\", \"method\": \"GET\" }, { \"href\": \"https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend\", \"rel\": \"resend\", \"method\": \"POST\" } ] }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/paypal-webhook") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .addHeader("string", "08ba2101-ead5-417d-8c7c-b978ade77aa1") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); myHeaders.append("string", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "id": "WH-94D876612G9263632-38K706545B7995038", "event_version": "1.0", "create_time": "2024-06-12T11:35:58.798Z", "resource_type": "subscription", "resource_version": "2.0", "event_type": "BILLING.SUBSCRIPTION.CREATED", "summary": "Subscription created", "resource": { "start_time": "2024-06-13T11:35:51Z", "quantity": "1", "create_time": "2024-06-12T11:35:58Z", "links": [ { "href": "https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S", "rel": "approve", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "edit", "method": "PATCH" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "self", "method": "GET" } ], "id": "I-UGRJ500PGTB2", "plan_overridden": false, "plan_id": "P-26L6297332438632CMZUYP2Y", "status": "APPROVAL_PENDING" }, "links": [ { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038", "rel": "self", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend", "rel": "resend", "method": "POST" } ] }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/paypal-webhook", 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://api.infinitemlmsoftware.com/auth/paypal-webhook" method := "POST" payload := strings.NewReader(`{ "id": "WH-94D876612G9263632-38K706545B7995038", "event_version": "1.0", "create_time": "2024-06-12T11:35:58.798Z", "resource_type": "subscription", "resource_version": "2.0", "event_type": "BILLING.SUBSCRIPTION.CREATED", "summary": "Subscription created", "resource": { "start_time": "2024-06-13T11:35:51Z", "quantity": "1", "create_time": "2024-06-12T11:35:58Z", "links": [ { "href": "https://www.sandbox.paypal.com/webapps/billing/subscriptions?ba_token=BA-75W013509L187320S", "rel": "approve", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "edit", "method": "PATCH" }, { "href": "https://api.sandbox.paypal.com/v1/billing/subscriptions/I-UGRJ500PGTB2", "rel": "self", "method": "GET" } ], "id": "I-UGRJ500PGTB2", "plan_overridden": false, "plan_id": "P-26L6297332438632CMZUYP2Y", "status": "APPROVAL_PENDING" }, "links": [ { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038", "rel": "self", "method": "GET" }, { "href": "https://api.sandbox.paypal.com/v1/notifications/webhooks-events/WH-94D876612G9263632-38K706545B7995038/resend", "rel": "resend", "method": "POST" } ] }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") req.Header.Add("string", "08ba2101-ead5-417d-8c7c-b978ade77aa1") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/auth/update-password"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "08ba2101-ead5-417d-8c7c-b978ade77aa1"); var content = new StringContent("{ \"password\": \"12345678\", \"hash\": \"ikgbwsdefwsedobhwdsjfr\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/auth/stripe-webhook

Header Parameters
Acceptstring
stripe-signaturestring
Body Parameters
idstring
objectstring
amountnumber
amount_capturablenumber
amount_detailsobject
tipobject
amount_receivednumber
applicationobject
application_fee_amountobject
automatic_payment_methodsobject
amount_detailsobject
canceled_atobject
cancellation_reasonobject
capture_methodstring
client_secretstring
confirmation_methodstring
creatednumber
currencystring
customerobject
descriptionobject
invoiceobject
last_payment_errorobject
latest_chargeobject
livemodeboolean
next_actionobject
on_behalf_ofobject
payment_methodobject
payment_method_optionsobject
cardobject
installmentsobject
mandate_optionsobject
networkobject
request_three_d_securestring
linkobject
persistent_tokenobject
payment_method_optionsarray
cardobject
linkstring
processingobject
receipt_emailobject
reviewobject
setup_future_usageobject
shippingobject
sourceobject
statement_descriptorobject
statement_descriptor_suffixobject
statusstring
transfer_dataobject
transfer_groupobject
POST/auth/stripe-webhook
curl --location 'https://api.infinitemlmsoftware.com/auth/stripe-webhook' \ --header 'Accept: application/json' \ --header 'Content-Type: application/json' \ --data '{ "id": "pi_3MtwBwLkdIwHu7ix28a3tqPa", "object": "payment_intent", "amount": 2000, "amount_capturable": 0, "amount_details": { "tip": {} }, "amount_received": 0, "application": {}, "application_fee_amount": {}, "automatic_payment_methods": { "enabled": true }, "canceled_at": {}, "cancellation_reason": {}, "capture_method": "automatic", "client_secret": "pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH", "confirmation_method": "automatic", "created": 1680800504, "currency": "usd", "customer": {}, "description": {}, "invoice": {}, "last_payment_error": {}, "latest_charge": {}, "livemode": false, "metadata": {}, "next_action": {}, "on_behalf_of": {}, "payment_method": {}, "payment_method_options": { "card": { "installments": {}, "mandate_options": {}, "network": {}, "request_three_d_secure": "automatic" }, "link": { "persistent_token": {} } }, "payment_method_types": [ "card", "link" ], "processing": {}, "receipt_email": {}, "review": {}, "setup_future_usage": {}, "shipping": {}, "source": {}, "statement_descriptor": {}, "statement_descriptor_suffix": {}, "status": "requires_payment_method", "transfer_data": {}, "transfer_group": {} }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/stripe-webhook") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["Content-Type"] = "application/json" request.body = JSON.dump({ "id": "pi_3MtwBwLkdIwHu7ix28a3tqPa", "object": "payment_intent", "amount": 2000, "amount_capturable": 0, "amount_details": { "tip": {} }, "amount_received": 0, "application": {}, "application_fee_amount": {}, "automatic_payment_methods": { "enabled": true }, "canceled_at": {}, "cancellation_reason": {}, "capture_method": "automatic", "client_secret": "pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH", "confirmation_method": "automatic", "created": 1680800504, "currency": "usd", "customer": {}, "description": {}, "invoice": {}, "last_payment_error": {}, "latest_charge": {}, "livemode": false, "metadata": {}, "next_action": {}, "on_behalf_of": {}, "payment_method": {}, "payment_method_options": { "card": { "installments": {}, "mandate_options": {}, "network": {}, "request_three_d_secure": "automatic" }, "link": { "persistent_token": {} } }, "payment_method_types": [ "card", "link" ], "processing": {}, "receipt_email": {}, "review": {}, "setup_future_usage": {}, "shipping": {}, "source": {}, "statement_descriptor": {}, "statement_descriptor_suffix": {}, "status": "requires_payment_method", "transfer_data": {}, "transfer_group": {} }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/auth/stripe-webhook" payload = json.dumps({ "id": "pi_3MtwBwLkdIwHu7ix28a3tqPa", "object": "payment_intent", "amount": 2000, "amount_capturable": 0, "amount_details": { "tip": {} }, "amount_received": 0, "application": {}, "application_fee_amount": {}, "automatic_payment_methods": { "enabled": True }, "canceled_at": {}, "cancellation_reason": {}, "capture_method": "automatic", "client_secret": "pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH", "confirmation_method": "automatic", "created": 1680800504, "currency": "usd", "customer": {}, "description": {}, "invoice": {}, "last_payment_error": {}, "latest_charge": {}, "livemode": False, "metadata": {}, "next_action": {}, "on_behalf_of": {}, "payment_method": {}, "payment_method_options": { "card": { "installments": {}, "mandate_options": {}, "network": {}, "request_three_d_secure": "automatic" }, "link": { "persistent_token": {} } }, "payment_method_types": [ "card", "link" ], "processing": {}, "receipt_email": {}, "review": {}, "setup_future_usage": {}, "shipping": {}, "source": {}, "statement_descriptor": {}, "statement_descriptor_suffix": {}, "status": "requires_payment_method", "transfer_data": {}, "transfer_group": {} }) headers = { 'Accept': 'application/json', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'Content-Type' => 'application/json' ]; $body = '{ "id": "pi_3MtwBwLkdIwHu7ix28a3tqPa", "object": "payment_intent", "amount": 2000, "amount_capturable": 0, "amount_details": { "tip": {} }, "amount_received": 0, "application": {}, "application_fee_amount": {}, "automatic_payment_methods": { "enabled": true }, "canceled_at": {}, "cancellation_reason": {}, "capture_method": "automatic", "client_secret": "pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH", "confirmation_method": "automatic", "created": 1680800504, "currency": "usd", "customer": {}, "description": {}, "invoice": {}, "last_payment_error": {}, "latest_charge": {}, "livemode": false, "metadata": {}, "next_action": {}, "on_behalf_of": {}, "payment_method": {}, "payment_method_options": { "card": { "installments": {}, "mandate_options": {}, "network": {}, "request_three_d_secure": "automatic" }, "link": { "persistent_token": {} } }, "payment_method_types": [ "card", "link" ], "processing": {}, "receipt_email": {}, "review": {}, "setup_future_usage": {}, "shipping": {}, "source": {}, "statement_descriptor": {}, "statement_descriptor_suffix": {}, "status": "requires_payment_method", "transfer_data": {}, "transfer_group": {} }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/auth/stripe-webhook', $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, "{ \"id\": \"pi_3MtwBwLkdIwHu7ix28a3tqPa\", \"object\": \"payment_intent\", \"amount\": 2000, \"amount_capturable\": 0, \"amount_details\": { \"tip\": {} }, \"amount_received\": 0, \"application\": {}, \"application_fee_amount\": {}, \"automatic_payment_methods\": { \"enabled\": true }, \"canceled_at\": {}, \"cancellation_reason\": {}, \"capture_method\": \"automatic\", \"client_secret\": \"pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH\", \"confirmation_method\": \"automatic\", \"created\": 1680800504, \"currency\": \"usd\", \"customer\": {}, \"description\": {}, \"invoice\": {}, \"last_payment_error\": {}, \"latest_charge\": {}, \"livemode\": false, \"metadata\": {}, \"next_action\": {}, \"on_behalf_of\": {}, \"payment_method\": {}, \"payment_method_options\": { \"card\": { \"installments\": {}, \"mandate_options\": {}, \"network\": {}, \"request_three_d_secure\": \"automatic\" }, \"link\": { \"persistent_token\": {} } }, \"payment_method_types\": [ \"card\", \"link\" ], \"processing\": {}, \"receipt_email\": {}, \"review\": {}, \"setup_future_usage\": {}, \"shipping\": {}, \"source\": {}, \"statement_descriptor\": {}, \"statement_descriptor_suffix\": {}, \"status\": \"requires_payment_method\", \"transfer_data\": {}, \"transfer_group\": {} }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/stripe-webhook") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "id": "pi_3MtwBwLkdIwHu7ix28a3tqPa", "object": "payment_intent", "amount": 2000, "amount_capturable": 0, "amount_details": { "tip": {} }, "amount_received": 0, "application": {}, "application_fee_amount": {}, "automatic_payment_methods": { "enabled": true }, "canceled_at": {}, "cancellation_reason": {}, "capture_method": "automatic", "client_secret": "pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH", "confirmation_method": "automatic", "created": 1680800504, "currency": "usd", "customer": {}, "description": {}, "invoice": {}, "last_payment_error": {}, "latest_charge": {}, "livemode": false, "metadata": {}, "next_action": {}, "on_behalf_of": {}, "payment_method": {}, "payment_method_options": { "card": { "installments": {}, "mandate_options": {}, "network": {}, "request_three_d_secure": "automatic" }, "link": { "persistent_token": {} } }, "payment_method_types": [ "card", "link" ], "processing": {}, "receipt_email": {}, "review": {}, "setup_future_usage": {}, "shipping": {}, "source": {}, "statement_descriptor": {}, "statement_descriptor_suffix": {}, "status": "requires_payment_method", "transfer_data": {}, "transfer_group": {} }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/stripe-webhook", 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://api.infinitemlmsoftware.com/auth/stripe-webhook" method := "POST" payload := strings.NewReader(`{ "id": "pi_3MtwBwLkdIwHu7ix28a3tqPa", "object": "payment_intent", "amount": 2000, "amount_capturable": 0, "amount_details": { "tip": {} }, "amount_received": 0, "application": {}, "application_fee_amount": {}, "automatic_payment_methods": { "enabled": true }, "canceled_at": {}, "cancellation_reason": {}, "capture_method": "automatic", "client_secret": "pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH", "confirmation_method": "automatic", "created": 1680800504, "currency": "usd", "customer": {}, "description": {}, "invoice": {}, "last_payment_error": {}, "latest_charge": {}, "livemode": false, "metadata": {}, "next_action": {}, "on_behalf_of": {}, "payment_method": {}, "payment_method_options": { "card": { "installments": {}, "mandate_options": {}, "network": {}, "request_three_d_secure": "automatic" }, "link": { "persistent_token": {} } }, "payment_method_types": [ "card", "link" ], "processing": {}, "receipt_email": {}, "review": {}, "setup_future_usage": {}, "shipping": {}, "source": {}, "statement_descriptor": {}, "statement_descriptor_suffix": {}, "status": "requires_payment_method", "transfer_data": {}, "transfer_group": {} }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/auth/stripe-webhook"); request.Headers.Add("Accept", "application/json"); var content = new StringContent("{ \"id\": \"pi_3MtwBwLkdIwHu7ix28a3tqPa\", \"object\": \"payment_intent\", \"amount\": 2000, \"amount_capturable\": 0, \"amount_details\": { \"tip\": {} }, \"amount_received\": 0, \"application\": {}, \"application_fee_amount\": {}, \"automatic_payment_methods\": { \"enabled\": true }, \"canceled_at\": {}, \"cancellation_reason\": {}, \"capture_method\": \"automatic\", \"client_secret\": \"pi_3MtwBwLkdIwHu7ix28a3tqPa_secret_YrKJUKribcBjcG8HVhfZluoGH\", \"confirmation_method\": \"automatic\", \"created\": 1680800504, \"currency\": \"usd\", \"customer\": {}, \"description\": {}, \"invoice\": {}, \"last_payment_error\": {}, \"latest_charge\": {}, \"livemode\": false, \"metadata\": {}, \"next_action\": {}, \"on_behalf_of\": {}, \"payment_method\": {}, \"payment_method_options\": { \"card\": { \"installments\": {}, \"mandate_options\": {}, \"network\": {}, \"request_three_d_secure\": \"automatic\" }, \"link\": { \"persistent_token\": {} } }, \"payment_method_types\": [ \"card\", \"link\" ], \"processing\": {}, \"receipt_email\": {}, \"review\": {}, \"setup_future_usage\": {}, \"shipping\": {}, \"source\": {}, \"statement_descriptor\": {}, \"statement_descriptor_suffix\": {}, \"status\": \"requires_payment_method\", \"transfer_data\": {}, \"transfer_group\": {} }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Dashboard

/dashboard-user-profile

Header Parameters
Acceptstring
access-tokenstring
api-keystring

/dashboard-tiles

Header Parameters
Acceptstring
access-tokenstring
api-keystring
GET/dashboard-tiles
curl --location 'https://api.infinitemlmsoftware.com/dashboard-user-profile' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/dashboard-user-profile") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/dashboard-user-profile" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/dashboard-user-profile', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/dashboard-user-profile") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/dashboard-user-profile", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/dashboard-user-profile" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/dashboard-user-profile"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get-tiles

Header Parameters
Acceptstring
access-tokenstring
api-keystring
Query Parameters
timeFramestring
optionsstring
GET/get-tiles
curl --location 'https://api.infinitemlmsoftware.com/auth/get-company-logo' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/get-company-logo") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/auth/get-company-logo" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/auth/get-company-logo', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/get-company-logo") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/get-company-logo", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/auth/get-company-logo" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/auth/get-company-logo"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get-graph

Header Parameters
Acceptstring
access-tokenstring
api-keystring
Query Parameters
timeFramestring
optionsstring
GET/get-graph
curl --location 'https://api.infinitemlmsoftware.com/auth/get-company-logo' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/auth/get-company-logo") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/auth/get-company-logo" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/auth/get-company-logo', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/auth/get-company-logo") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/auth/get-company-logo", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/auth/get-company-logo" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/auth/get-company-logo"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Ewallet

/ewallet tiles

Header Parameters
api-keystring
access-tokenstring
GET/ewallet tiles
curl --location 'https://api.infinitemlmsoftware.com/ewallet-tiles' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/ewallet-tiles") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/ewallet-tiles" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/ewallet-tiles', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/ewallet-tiles") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/ewallet-tiles", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/ewallet-tiles" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/ewallet-tiles"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/ewallet-transfer-histories

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
typestring
startDatestring
endDatestring
pagestring
perPagestring
GET/ewallet-transfer-histories
curl --location 'https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/ewallet-transfer-history?startDate=2023-06-06&endDate=2023-08-12&page=1&perPage=10"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Ewallet-statement

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
pagestring
perPagestring
GET/Ewallet-statement
curl --location 'https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/ewallet-statement?page=1&perPage=10"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/purchase-wallet

Header Parameters
access-tokenstring
api-keystring
Query Parameters
pagestring
perPagestring
GET/purchase-wallet
curl --location 'https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/purchase-wallet?page=1&perPage=3"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/my-earnings

Header Parameters
access-tokenstring
api-keystring
Query Parameters
pagestring
perPagestring
startDatestring
endDatestring
directionstring
typestring
GET/my-earnings
curl --location --globoff 'https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/my-earnings?page=1&perPage=5&direction=desc&type=[]"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Fund-transfer

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
usernamestring
amountnumber
transactionPasswordstring
POST/Fund-transfer
curl --location 'https://api.infinitemlmsoftware.com/fund-transfer' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "username": "INF1588003019454", "amount": 10, "transactionPassword": "12345678" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/fund-transfer") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "username": "INF1588003019454", "amount": 10, "transactionPassword": "12345678" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/fund-transfer" payload = json.dumps({ "username": "INF1588003019454", "amount": 10, "transactionPassword": "12345678" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "username": "INF1588003019454", "amount": 10, "transactionPassword": "12345678" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/fund-transfer', $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, "{ \"username\": \"INF1588003019454\", \"amount\": 10, \"transactionPassword\": \"12345678\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/fund-transfer") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "username": "INF1588003019454", "amount": 10, "transactionPassword": "12345678" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/fund-transfer", 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://api.infinitemlmsoftware.com/fund-transfer" method := "POST" payload := strings.NewReader(`{ "username": "INF1588003019454", "amount": 10, "transactionPassword": "12345678" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/fund-transfer"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"username\": \"INF1588003019454\", \"amount\": 10, \"transactionPassword\": \"12345678\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Utility

/appLayout

Header Parameters
api-keystring
access-tokenstring
GET/appLayout
curl --location 'https://api.infinitemlmsoftware.com/app-layout' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/app-layout") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/app-layout" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/app-layout', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/app-layout") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/app-layout", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/app-layout" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") 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.Get, "https://api.infinitemlmsoftware.com/app-layout"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/change-currency

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
currencyIdstring
PATCH/change-currency
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/change-currency' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json' \ --header 'Content-Type: application/json' \ --data '{ "currencyId": "218" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/change-currency") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" request["Content-Type"] = "application/json" request.body = JSON.dump({ "currencyId": "218" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/change-currency" payload = json.dumps({ "currencyId": "218" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Accept': 'application/json', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json', 'Content-Type' => 'application/json' ]; $body = '{ "currencyId": "218" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/change-currency', $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, "{ \"currencyId\": \"218\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/change-currency") .method("PATCH", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "currencyId": "218" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/change-currency", 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://api.infinitemlmsoftware.com/change-currency" method := "PATCH" payload := strings.NewReader(`{ "currencyId": "218" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/change-currency"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); var content = new StringContent("{ \"currencyId\": \"218\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/change language

Header Parameters
api-keystring
access-tokenstring
Acceptstring
Body Parameters
langIdstring
PATCH/change-language
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/change-language' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Accept: application/json' \ --header 'Content-Type: application/json' \ --data '{ "langId": "2" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/change-language") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Accept"] = "application/json" request["Content-Type"] = "application/json" request.body = JSON.dump({ "langId": "2" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/change-language" payload = json.dumps({ "langId": "2" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Accept': 'application/json', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Accept' => 'application/json', 'Content-Type' => 'application/json' ]; $body = '{ "langId": "2" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/change-language', $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, "{ \"langId\": \"2\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/change-language") .method("PATCH", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Accept", "application/json") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Accept", "application/json"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "langId": "2" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/change-language", 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://api.infinitemlmsoftware.com/change-language" method := "PATCH" payload := strings.NewReader(`{ "langId": "2" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/change-language"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("Accept", "application/json"); var content = new StringContent("{ \"langId\": \"2\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

epin

/epin-list

Header Parameters
api-keystring
access-tokenstring
Query Parameters
pagestring
perPagestring
statusstring
optionsstring
epinsstring
amountsstring
directionstring
GET/epin-list
curl --location --globoff 'https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active%2Cblocked%2Cdeleted%2Cused%2Cexpired&epins=[]&amounts=[]' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active,blocked,deleted,used,expired&epins=[]&amounts=[]") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active,blocked,deleted,used,expired&epins=[]&amounts=[]" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active,blocked,deleted,used,expired&epins=[]&amounts=[]', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active,blocked,deleted,used,expired&epins=[]&amounts=[]") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active,blocked,deleted,used,expired&epins=[]&amounts=[]", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active%2Cblocked%2Cdeleted%2Cused%2Cexpired&epins=[]&amounts=[]" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/epin-list?page=1&perPage=10&status=active&options=active,blocked,deleted,used,expired&epins=[]&amounts=[]"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/epin-tiles

Header Parameters
api-keystring
access-tokenstring
get/epin-tiles
curl --location 'https://api.infinitemlmsoftware.com/epin-tiles' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-tiles") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-tiles" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/epin-tiles', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-tiles") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-tiles", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/epin-tiles" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/epin-tiles"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/pending-epin-request

Header Parameters
api-keystring
access-tokenstring
Query Parameters
pagestring
perPagestring
directionstring
get/pending-epin-request
curl --location 'https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/pending-epin-request?page=1&perPage=3&direction=asc"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/epin-transfer-history

Header Parameters
api-keystring
access-tokenstring
Query Parameters
pagestring
perPagestring
directionstring
PATCH/change-language
curl --location 'https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/epin-transfer-history?page=1&perPage=10&direction=ASC"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/epin-purchase

Header Parameters
api-keystring
access-tokenstring
Content-Typestring
Query Parameters
directionstring
POST/epin-purchase
curl --location 'https://api.infinitemlmsoftware.com/epin-purchase?direction=ASC' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "epinCount": "2", "amountCode": [ 2, 5 ], "transactionPassword": "12345678", "expiryDate": "12-22-2023" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-purchase?direction=ASC") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "epinCount": "2", "amountCode": [ 2, 5 ], "transactionPassword": "12345678", "expiryDate": "12-22-2023" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-purchase?direction=ASC" payload = json.dumps({ "epinCount": "2", "amountCode": [ 2, 5 ], "transactionPassword": "12345678", "expiryDate": "12-22-2023" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "epinCount": "2", "amountCode": [ 2, 5 ], "transactionPassword": "12345678", "expiryDate": "12-22-2023" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/epin-purchase?direction=ASC', $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, "{ \"epinCount\": \"2\", \"amountCode\": [ 2, 5 ], \"transactionPassword\": \"12345678\", \"expiryDate\": \"12-22-2023\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-purchase?direction=ASC") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "epinCount": "2", "amountCode": [ 2, 5 ], "transactionPassword": "12345678", "expiryDate": "12-22-2023" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-purchase?direction=ASC", 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://api.infinitemlmsoftware.com/epin-purchase?direction=ASC" method := "POST" payload := strings.NewReader(`{ "epinCount": "2", "amountCode": [ 2, 5 ], "transactionPassword": "12345678", "expiryDate": "12-22-2023" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/epin-purchase?direction=ASC"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"epinCount\": \"2\", \"amountCode\": [ 2, 5 ], \"transactionPassword\": \"12345678\", \"expiryDate\": \"12-22-2023\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/epin-request

Header Parameters
api-keystring
access-tokenstring
Content-Typestring
Query Parameters
directionstring
Body Parameters
epinCountstring
amountCodearray
2number
5number
expiryDatestring
POST/epin-request
curl --location 'https://api.infinitemlmsoftware.com/epin-request?direction=ASC' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "epinCount": "3", "amountCode": [ 2, 5 ], "expiryDate": "2023-08-21" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-request?direction=ASC") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "epinCount": "3", "amountCode": [ 2, 5 ], "expiryDate": "2023-08-21" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-request?direction=ASC" payload = json.dumps({ "epinCount": "3", "amountCode": [ 2, 5 ], "expiryDate": "2023-08-21" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "epinCount": "3", "amountCode": [ 2, 5 ], "expiryDate": "2023-08-21" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/epin-request?direction=ASC', $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, "{ \"epinCount\": \"3\", \"amountCode\": [ 2, 5 ], \"expiryDate\": \"2023-08-21\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-request?direction=ASC") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "epinCount": "3", "amountCode": [ 2, 5 ], "expiryDate": "2023-08-21" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-request?direction=ASC", 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://api.infinitemlmsoftware.com/epin-request?direction=ASC" method := "POST" payload := strings.NewReader(`{ "epinCount": "3", "amountCode": [ 2, 5 ], "expiryDate": "2023-08-21" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/epin-request?direction=ASC"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"epinCount\": \"3\", \"amountCode\": [ 2, 5 ], \"expiryDate\": \"2023-08-21\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/epin-transfer

Header Parameters
api-keystring
access-tokenstring
Content-Typestring
Query Parameters
directionstring
Body Parameters
epinarray
IQ3zt1ji06ZUustring
kA_lD49EeYKBmstring
toUsernamestring
POST/epin-transfer
curl --location 'https://api.infinitemlmsoftware.com/epin-transfer?direction=ASC' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "epin": [ "IQ3zt1ji06ZUu", "kA_lD49EeYKBm" ], "toUsername": "TESTER2" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-transfer?direction=ASC") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "epin": [ "IQ3zt1ji06ZUu", "kA_lD49EeYKBm" ], "toUsername": "TESTER2" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-transfer?direction=ASC" payload = json.dumps({ "epin": [ "IQ3zt1ji06ZUu", "kA_lD49EeYKBm" ], "toUsername": "TESTER2" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "epin": [ "IQ3zt1ji06ZUu", "kA_lD49EeYKBm" ], "toUsername": "TESTER2" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/epin-transfer?direction=ASC', $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, "{ \"epin\": [ \"IQ3zt1ji06ZUu\", \"kA_lD49EeYKBm\" ], \"toUsername\": \"TESTER2\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-transfer?direction=ASC") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "epin": [ "IQ3zt1ji06ZUu", "kA_lD49EeYKBm" ], "toUsername": "TESTER2" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-transfer?direction=ASC", 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://api.infinitemlmsoftware.com/epin-transfer?direction=ASC" method := "POST" payload := strings.NewReader(`{ "epin": [ "IQ3zt1ji06ZUu", "kA_lD49EeYKBm" ], "toUsername": "TESTER2" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/epin-transfer?direction=ASC"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"epin\": [ \"IQ3zt1ji06ZUu\", \"kA_lD49EeYKBm\" ], \"toUsername\": \"TESTER2\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/epin-refund

Header Parameters
api-keystring
access-tokenstring
Content-Typestring
Query Parameters
directionstring
Body Parameters
epinstring
POST/epin-refund
curl --location 'https://api.infinitemlmsoftware.com/epin-refund?direction=ASC' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "epin": "QT1kP4kVxS" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/epin-refund?direction=ASC") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "epin": "QT1kP4kVxS" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/epin-refund?direction=ASC" payload = json.dumps({ "epin": "QT1kP4kVxS" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "epin": "QT1kP4kVxS" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/epin-refund?direction=ASC', $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, "{ \"epin\": \"QT1kP4kVxS\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/epin-refund?direction=ASC") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "epin": "QT1kP4kVxS" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/epin-refund?direction=ASC", 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://api.infinitemlmsoftware.com/epin-refund?direction=ASC" method := "POST" payload := strings.NewReader(`{ "epin": "QT1kP4kVxS" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/epin-refund?direction=ASC"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"epin\": \"QT1kP4kVxS\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Register

register

Header Parameters
api-keystring
access-tokenstring
Query Parameters
fatherstring
positionstring
GETregister
curl --location 'https://api.infinitemlmsoftware.com/register?father=tester8&position=2' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/register?father=tester8&position=2") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/register?father=tester8&position=2" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/register?father=tester8&position=2', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/register?father=tester8&position=2") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/register?father=tester8&position=2", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/register?father=tester8&position=2" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/register?father=tester8&position=2"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/register-user

Header Parameters
api-keystring
access-tokenstring
Body Parameters
date_of_birthstring
emailstring
first_namestring
genderstring
mobilestring
passwordstring
paymentTypenumber
productobject
idnumber
termsAndConditionboolean
usernamestring
POST/register-user
curl --location 'https://api.infinitemlmsoftware.com/register' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data-raw '{ "date_of_birth": "2003-07-17", "email": "[email protected]", "first_name": "Wallace", "gender": "female", "mobile": "9447165419", "password": "12345678", "paymentType": 3, "placement": "L", "position": "L", "product": { "id": 1 }, "termsAndCondition": true, "username": "[email protected]" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/register") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "date_of_birth": "2003-07-17", "email": "[email protected]", "first_name": "Wallace", "gender": "female", "mobile": "9447165419", "password": "12345678", "paymentType": 3, "placement": "L", "position": "L", "product": { "id": 1 }, "termsAndCondition": true, "username": "[email protected]" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/register" payload = json.dumps({ "date_of_birth": "2003-07-17", "email": "[email protected]", "first_name": "Wallace", "gender": "female", "mobile": "9447165419", "password": "12345678", "paymentType": 3, "placement": "L", "position": "L", "product": { "id": 1 }, "termsAndCondition": True, "username": "[email protected]" }) headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "date_of_birth": "2003-07-17", "email": "[email protected]", "first_name": "Wallace", "gender": "female", "mobile": "9447165419", "password": "12345678", "paymentType": 3, "placement": "L", "position": "L", "product": { "id": 1 }, "termsAndCondition": true, "username": "[email protected]" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/register', $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, "{ \"date_of_birth\": \"2003-07-17\", \"email\": \"[email protected]\", \"first_name\": \"Wallace\", \"gender\": \"female\", \"mobile\": \"9447165419\", \"password\": \"12345678\", \"paymentType\": 3, \"placement\": \"L\", \"position\": \"L\", \"product\": { \"id\": 1 }, \"termsAndCondition\": true, \"username\": \"[email protected]\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/register") .method("POST", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "date_of_birth": "2003-07-17", "email": "[email protected]", "first_name": "Wallace", "gender": "female", "mobile": "9447165419", "password": "12345678", "paymentType": 3, "placement": "L", "position": "L", "product": { "id": 1 }, "termsAndCondition": true, "username": "[email protected]" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/register", 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://api.infinitemlmsoftware.com/register" method := "POST" payload := strings.NewReader(`{ "date_of_birth": "2003-07-17", "email": "[email protected]", "first_name": "Wallace", "gender": "female", "mobile": "9447165419", "password": "12345678", "paymentType": 3, "placement": "L", "position": "L", "product": { "id": 1 }, "termsAndCondition": true, "username": "[email protected]" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/register"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"date_of_birth\": \"2003-07-17\", \"email\": \"[email protected]\", \"first_name\": \"Wallace\", \"gender\": \"female\", \"mobile\": \"9447165419\", \"password\": \"12345678\", \"paymentType\": 3, \"placement\": \"L\", \"position\": \"L\", \"product\": { \"id\": 1 }, \"termsAndCondition\": true, \"username\": \"[email protected]\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/register-field-verification

Header Parameters
api-keystring
access-tokenstring
Query Parameters
fieldstring
valuestring
GET/register-field-verification
curl --location 'https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") 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.Get, "https://api.infinitemlmsoftware.com/register-field-verification?field=username&value=TESTER2"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Profile

profile

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/profile
curl --location 'https://api.infinitemlmsoftware.com/profile-view' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/profile-view") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/profile-view" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/profile-view', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/profile-view") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/profile-view", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/profile-view" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/profile-view"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update personal details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
namestring
secondNamestring
genderstring
PATCH/update personal details
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/update-personal-details' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "name": "first name", "secondName": "scond name", "gender": "F" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-personal-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "name": "first name", "secondName": "scond name", "gender": "F" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/update-personal-details" payload = json.dumps({ "name": "first name", "secondName": "scond name", "gender": "F" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "name": "first name", "secondName": "scond name", "gender": "F" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/update-personal-details', $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, "{ \"name\": \"first name\", \"secondName\": \"scond name\", \"gender\": \"F\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-personal-details") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "name": "first name", "secondName": "scond name", "gender": "F" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-personal-details", 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://api.infinitemlmsoftware.com/update-personal-details" method := "PATCH" payload := strings.NewReader(`{ "name": "first name", "secondName": "scond name", "gender": "F" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/update-personal-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"name\": \"first name\", \"secondName\": \"scond name\", \"gender\": \"F\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update contact details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
addressstring
address2string
countrystring
statestring
citystring
zipCodestring
mobilestring
PATCH/update contact details
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/update-contact-details' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "address": "first name", "address2": "scond name", "country": "91", "state": "2", "city": "sdasd", "zipCode": "54545", "mobile": "56464665464" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-contact-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "address": "first name", "address2": "scond name", "country": "91", "state": "2", "city": "sdasd", "zipCode": "54545", "mobile": "56464665464" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/update-contact-details" payload = json.dumps({ "address": "first name", "address2": "scond name", "country": "91", "state": "2", "city": "sdasd", "zipCode": "54545", "mobile": "56464665464" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "address": "first name", "address2": "scond name", "country": "91", "state": "2", "city": "sdasd", "zipCode": "54545", "mobile": "56464665464" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/update-contact-details', $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, "{ \"address\": \"first name\", \"address2\": \"scond name\", \"country\": \"91\", \"state\": \"2\", \"city\": \"sdasd\", \"zipCode\": \"54545\", \"mobile\": \"56464665464\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-contact-details") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "address": "first name", "address2": "scond name", "country": "91", "state": "2", "city": "sdasd", "zipCode": "54545", "mobile": "56464665464" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-contact-details", 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://api.infinitemlmsoftware.com/update-contact-details" method := "PATCH" payload := strings.NewReader(`{ "address": "first name", "address2": "scond name", "country": "91", "state": "2", "city": "sdasd", "zipCode": "54545", "mobile": "56464665464" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/update-contact-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"address\": \"first name\", \"address2\": \"scond name\", \"country\": \"91\", \"state\": \"2\", \"city\": \"sdasd\", \"zipCode\": \"54545\", \"mobile\": \"56464665464\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update-bank-details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
bankNamestring
branchNamestring
holderNamestring
accountNostring
ifscstring
panstring
PATCH/update-bank-details
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/update-bank-details' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "bankName": "first name", "branchName": "scond name", "holderName": "91", "accountNo": "2", "ifsc": "sdasd", "pan": "54545" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-bank-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "bankName": "first name", "branchName": "scond name", "holderName": "91", "accountNo": "2", "ifsc": "sdasd", "pan": "54545" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/update-bank-details" payload = json.dumps({ "bankName": "first name", "branchName": "scond name", "holderName": "91", "accountNo": "2", "ifsc": "sdasd", "pan": "54545" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "bankName": "first name", "branchName": "scond name", "holderName": "91", "accountNo": "2", "ifsc": "sdasd", "pan": "54545" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/update-bank-details', $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, "{ \"bankName\": \"first name\", \"branchName\": \"scond name\", \"holderName\": \"91\", \"accountNo\": \"2\", \"ifsc\": \"sdasd\", \"pan\": \"54545\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-bank-details") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "bankName": "first name", "branchName": "scond name", "holderName": "91", "accountNo": "2", "ifsc": "sdasd", "pan": "54545" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-bank-details", 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://api.infinitemlmsoftware.com/update-bank-details" method := "PATCH" payload := strings.NewReader(`{ "bankName": "first name", "branchName": "scond name", "holderName": "91", "accountNo": "2", "ifsc": "sdasd", "pan": "54545" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/update-bank-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"bankName\": \"first name\", \"branchName\": \"scond name\", \"holderName\": \"91\", \"accountNo\": \"2\", \"ifsc\": \"sdasd\", \"pan\": \"54545\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update-payment-details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
stripeAccountstring
branchstring
PATCH/update-payment-details
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/update-payment-details' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "stripeAccount": "dfbradsfr", "branch": "scond name", "paymentMethod": 5 }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-payment-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "stripeAccount": "dfbradsfr", "branch": "scond name", "paymentMethod": 5 }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/update-payment-details" payload = json.dumps({ "stripeAccount": "dfbradsfr", "branch": "scond name", "paymentMethod": 5 }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "stripeAccount": "dfbradsfr", "branch": "scond name", "paymentMethod": 5 }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/update-payment-details', $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, "{ \"stripeAccount\": \"dfbradsfr\", \"branch\": \"scond name\", \"paymentMethod\": 5 }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-payment-details") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "stripeAccount": "dfbradsfr", "branch": "scond name", "paymentMethod": 5 }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-payment-details", 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://api.infinitemlmsoftware.com/update-payment-details" method := "PATCH" payload := strings.NewReader(`{ "stripeAccount": "dfbradsfr", "branch": "scond name", "paymentMethod": 5 }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/update-payment-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"stripeAccount\": \"dfbradsfr\", \"branch\": \"scond name\", \"paymentMethod\": 5 }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update-settings

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
stripeAccountstring
branchstring
PATCH/update-settings
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/update-payment-details' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "stripeAccount": "first name", "branch": "scond name" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-payment-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "stripeAccount": "first name", "branch": "scond name" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/update-payment-details" payload = json.dumps({ "stripeAccount": "first name", "branch": "scond name" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "stripeAccount": "first name", "branch": "scond name" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/update-payment-details', $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, "{ \"stripeAccount\": \"first name\", \"branch\": \"scond name\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-payment-details") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "stripeAccount": "first name", "branch": "scond name" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-payment-details", 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://api.infinitemlmsoftware.com/update-payment-details" method := "PATCH" payload := strings.NewReader(`{ "stripeAccount": "first name", "branch": "scond name" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/update-payment-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"stripeAccount\": \"first name\", \"branch\": \"scond name\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/remove-avatar

Header Parameters
Acceptstring
api-keystring
access-tokenstring
PATCH/remove-avatar
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/remove-avatar' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/remove-avatar") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/remove-avatar" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}' ]; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/remove-avatar', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/remove-avatar") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); var requestOptions = { method: 'PATCH', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/remove-avatar", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/remove-avatar" method := "PATCH" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") 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.Patch, "https://api.infinitemlmsoftware.com/remove-avatar"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update avatar

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
filefile
POST/update avatar
curl --location --request POST 'https://api.infinitemlmsoftware.com/update-avatar' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-avatar") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" form_data = [] request.set_form form_data, 'multipart/form-data' response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/update-avatar" payload = {} files={} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}' } response = requests.request("POST", url, headers=headers, data=payload, files=files) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}' ]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/update-avatar', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); MediaType JSON = MediaType.parse("application/json; charset=utf-8"); RequestBody body = RequestBody.create(JSON, "{}"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-avatar") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); var formdata = new FormData(); var requestOptions = { method: 'POST', headers: myHeaders, body: formdata, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-avatar", 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://api.infinitemlmsoftware.com/update-avatar" method := "POST" payload := &bytes.Buffer{} writer := multipart.NewWriter(payload) 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.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") 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://api.infinitemlmsoftware.com/update-avatar"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/change-user-password

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
currentPasswordstring
newPasswordstring
passwordConfirmstring
PATCH/change-user-password
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/change-user-password' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "currentPassword": "1234567897", "newPassword": "12345678", "passwordConfirm": "12345678" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/change-user-password") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "currentPassword": "1234567897", "newPassword": "12345678", "passwordConfirm": "12345678" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/change-user-password" payload = json.dumps({ "currentPassword": "1234567897", "newPassword": "12345678", "passwordConfirm": "12345678" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "currentPassword": "1234567897", "newPassword": "12345678", "passwordConfirm": "12345678" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/change-user-password', $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, "{ \"currentPassword\": \"1234567897\", \"newPassword\": \"12345678\", \"passwordConfirm\": \"12345678\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/change-user-password") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "currentPassword": "1234567897", "newPassword": "12345678", "passwordConfirm": "12345678" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/change-user-password", 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://api.infinitemlmsoftware.com/change-user-password" method := "PATCH" payload := strings.NewReader(`{ "currentPassword": "1234567897", "newPassword": "12345678", "passwordConfirm": "12345678" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/change-user-password"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"currentPassword\": \"1234567897\", \"newPassword\": \"12345678\", \"passwordConfirm\": \"12345678\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/change-transaction-password

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
currentPasswordstring
newPasswordstring
passwordConfirmstring
PATCH/change-transaction-password
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/change-transaction-password' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' \ --data '{ "currentPassword": "12345678", "newPassword": "qwertyui", "passwordConfirm": "qwertyui" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/change-transaction-password") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "currentPassword": "12345678", "newPassword": "qwertyui", "passwordConfirm": "qwertyui" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/change-transaction-password" payload = json.dumps({ "currentPassword": "12345678", "newPassword": "qwertyui", "passwordConfirm": "qwertyui" }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $body = '{ "currentPassword": "12345678", "newPassword": "qwertyui", "passwordConfirm": "qwertyui" }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/change-transaction-password', $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, "{ \"currentPassword\": \"12345678\", \"newPassword\": \"qwertyui\", \"passwordConfirm\": \"qwertyui\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/change-transaction-password") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "currentPassword": "12345678", "newPassword": "qwertyui", "passwordConfirm": "qwertyui" }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/change-transaction-password", 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://api.infinitemlmsoftware.com/change-transaction-password" method := "PATCH" payload := strings.NewReader(`{ "currentPassword": "12345678", "newPassword": "qwertyui", "passwordConfirm": "qwertyui" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/change-transaction-password"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent("{ \"currentPassword\": \"12345678\", \"newPassword\": \"qwertyui\", \"passwordConfirm\": \"qwertyui\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/kyc-details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
currentPasswordstring
newPasswordstring
passwordConfirmstring
GET/kyc-details
curl --location 'https://api.infinitemlmsoftware.com/kyc-details' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/kyc-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/kyc-details" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/kyc-details', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/kyc-details") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/kyc-details", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/kyc-details" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") 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.Get, "https://api.infinitemlmsoftware.com/kyc-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/kyc-upload

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
filestring
categorystring
POST/kyc-upload
curl --location 'https://api.infinitemlmsoftware.com/kyc-upload?category=2' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --form 'category="2"'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/kyc-upload?category=2") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" form_data = [['category', '2']] request.set_form form_data, 'multipart/form-data' response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/kyc-upload?category=2" payload = {'category': '2'} files=[ ] headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}' } response = requests.request("POST", url, headers=headers, data=payload, files=files) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}' ]; $options = [ 'multipart' => [ [ 'name' => 'category', 'contents' => '2' ] ]]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/kyc-upload?category=2', $headers); $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("category","2") .build(); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/kyc-upload?category=2") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); var formdata = new FormData(); formdata.append("category", "2"); var requestOptions = { method: 'POST', headers: myHeaders, body: formdata, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/kyc-upload?category=2", 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://api.infinitemlmsoftware.com/kyc-upload?category=2" method := "POST" payload := &bytes.Buffer{} writer := multipart.NewWriter(payload) _ = writer.WriteField("category", "2") 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.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") 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://api.infinitemlmsoftware.com/kyc-upload?category=2"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new MultipartFormDataContent(); content.Add(new StringContent("2"), "category"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Tree

Genealogy Tree

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
userIdstring
GET/genealogy_tree
curl --location 'https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-genealogy-tree?userId=15"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Sponsor Tree

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
userIdstring
GET/get-sponsor-tree?userId=9
curl --location 'https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-sponsor-tree?userId=9"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/tree view

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
userIdstring
GET/get-tree-view?userId=4
curl --location 'https://api.infinitemlmsoftware.com/get-tree-view?userId=4' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-tree-view?userId=4") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-tree-view?userId=4" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-tree-view?userId=4', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-tree-view?userId=4") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-tree-view?userId=4", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-tree-view?userId=4" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-tree-view?userId=4"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Downline Header

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-downline-header
curl --location 'https://api.infinitemlmsoftware.com/get-downline-header' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-downline-header") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-downline-header" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-downline-header', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-downline-header") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-downline-header", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-downline-header" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-downline-header"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Downline Header

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-downline-header
curl --location 'https://api.infinitemlmsoftware.com/get-downline-header' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-downline-header") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-downline-header" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-downline-header', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-downline-header") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-downline-header", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-downline-header" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-downline-header"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Referral Header

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-referral-header
curl --location 'https://api.infinitemlmsoftware.com/get-referral-header' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json' }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-referral-header") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-referral-header" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-referral-header', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-referral-header") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-referral-header", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-referral-header" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-referral-header"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/Referrals

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-referrals
curl --location 'https://api.infinitemlmsoftware.com/get-referrals' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-referrals") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-referrals" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-referrals', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-referrals") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-referrals", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-referrals" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-referrals"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Unilevel More

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
fatherIdstring
positionstring
GET/get-unilevel-more?fatherId=3&position=4
curl --location 'https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-unilevel-more?fatherId=3&position=4"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get sponsor tree more

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
sponsorIdstring
positionstring
GET/get-sponsor-tree-more?sponsorId=6&position=4
curl --location 'https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-sponsor-tree-more?sponsorId=6&position=4"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

payout

/payout-details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
pagestring
perPagestring
statusstring
optionsstring
GET/payout-details
curl --location 'https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested%2Capproved%2Cpaid%2Crejected' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested,approved,paid,rejected") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested,approved,paid,rejected" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested,approved,paid,rejected', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested,approved,paid,rejected") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested,approved,paid,rejected", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested%2Capproved%2Cpaid%2Crejected" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/payout-details?page=1&perPage=10&status=requested&options=requested,approved,paid,rejected"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/payout-request-details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/payout-request-details
curl --location 'https://api.infinitemlmsoftware.com/payout-request-details' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/payout-request-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/payout-request-details" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/payout-request-details', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/payout-request-details") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/payout-request-details", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/payout-request-details" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/payout-request-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/payout-request-cancel

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
pagestring
pageSizestring
statusstring
Body Parameters
payoutIdArrArray
5number
6number
7number
8number
POST/payout-request-cancel
curl --location 'https://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "payoutIdArr": [ 5, 6, 7, 8 ] }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "payoutIdArr": [ 5, 6, 7, 8 ] }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid" payload = json.dumps({ "payoutIdArr": [ 5, 6, 7, 8 ] }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "payoutIdArr": [ 5, 6, 7, 8 ] }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid', $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, "{ \"payoutIdArr\": [ 5, 6, 7, 8 ] }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "payoutIdArr": [ 5, 6, 7, 8 ] }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid", 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://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid" method := "POST" payload := strings.NewReader(`{ "payoutIdArr": [ 5, 6, 7, 8 ] }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/payout-request-cancel?page=1&pageSize=10&status=paid"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"payoutIdArr\": [ 5, 6, 7, 8 ] }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/payout-request

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
payoutAmountnumber
transactionPasswordstring
GET/payout-request
curl --location 'https://api.infinitemlmsoftware.com/payout-request' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "payoutAmount": 12, "transactionPassword": "12345678" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/payout-request") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "payoutAmount": 12, "transactionPassword": "12345678" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/payout-request" payload = json.dumps({ "payoutAmount": 12, "transactionPassword": "12345678" }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "payoutAmount": 12, "transactionPassword": "12345678" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/payout-request', $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, "{ \"payoutAmount\": 12, \"transactionPassword\": \"12345678\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/payout-request") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "payoutAmount": 12, "transactionPassword": "12345678" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/payout-request", 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://api.infinitemlmsoftware.com/payout-request" method := "POST" payload := strings.NewReader(`{ "payoutAmount": 12, "transactionPassword": "12345678" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/payout-request"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"payoutAmount\": 12, \"transactionPassword\": \"12345678\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

shoppingCart

/repurchase-products

Header Parameters
Acceptstring
access-tokenstring
api-keystring
GET/repurchase-products
curl --location 'https://api.infinitemlmsoftware.com/repurchase-products' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/repurchase-products") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/repurchase-products" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/repurchase-products', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/repurchase-products") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/repurchase-products", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/repurchase-products" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/repurchase-products"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/payment-methods

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
actionstring
GET/payment-methods?action=repurchase
curl --location 'https://api.infinitemlmsoftware.com/payment-methods?action=repurchase' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/payment-methods?action=repurchase") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/payment-methods?action=repurchase" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/payment-methods?action=repurchase', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/payout-request-details") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/payment-methods?action=repurchase", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/payment-methods?action=repurchase" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/payment-methods?action=repurchase"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get-cart

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-cart
curl --location 'https://api.infinitemlmsoftware.com/get-cart' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-cart") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-cart" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-cart', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-cart") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-cart", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-cart" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-cart"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/add-to-cart

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
packageIdnumber
quantitynumber
POST/add-to-cart
curl --location 'https://api.infinitemlmsoftware.com/add-to-cart' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "packageId": 6, "quantity": 3 }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/add-to-cart") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "packageId": 6, "quantity": 3 }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/add-to-cart" payload = json.dumps({ "packageId": 6, "quantity": 3 }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "packageId": 6, "quantity": 3 }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/add-to-cart', $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, "{ \"packageId\": 6, \"quantity\": 3 }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/add-to-cart") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "packageId": 6, "quantity": 3 }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/add-to-cart", 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://api.infinitemlmsoftware.com/add-to-cart" method := "POST" payload := strings.NewReader(`{ "packageId": 6, "quantity": 3 }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/add-to-cart"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"packageId\": 6, \"quantity\": 3 }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/update-cart-item

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
cartIdnumber
Body Parameters
quantitynumber
PATCH/update-cart-item?cartId=13
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/update-cart-item?cartId=13' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "quantity": 3 }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/update-cart-item?cartId=13") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "quantity": 3 }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/update-cart-item?cartId=13" payload = json.dumps({ "quantity": 3 }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "quantity": 3 }'; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/update-cart-item?cartId=13', $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, "{ \"quantity\": 3 }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/update-cart-item?cartId=13") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "quantity": 3 }); var requestOptions = { method: 'PATCH', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/update-cart-item?cartId=13", 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://api.infinitemlmsoftware.com/update-cart-item?cartId=13" method := "PATCH" payload := strings.NewReader(`{ "quantity": 3 }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Patch, "https://api.infinitemlmsoftware.com/update-cart-item?cartId=13"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"quantity\": 3 }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/remove-cart-item

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
cartIdstring
DELETE/remove-cart-item?cartId=3
curl --location --request DELETE 'https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Delete.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("DELETE", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('DELETE', 'https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3") .method("DELETE", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'DELETE', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3" method := "DELETE" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Delete, "https://api.infinitemlmsoftware.com/remove-cart-item?cartId=3"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get-address

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-address
curl --location 'https://api.infinitemlmsoftware.com/get-address' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-address") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-address" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-address', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-address") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-address", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-address" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-address"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/add-address

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
namestring
addressstring
zipCodestring
citystring
phoneNumberstring
POST/add-address
curl --location 'https://api.infinitemlmsoftware.com/add-address' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "name": "Carson Conway", "address": "42, Eos perferendis temp", "zipCode": "13463", "city": "Mollit laboris dolor", "phoneNumber": "1234567890" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/add-address") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "name": "Carson Conway", "address": "42, Eos perferendis temp", "zipCode": "13463", "city": "Mollit laboris dolor", "phoneNumber": "1234567890" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/add-address" payload = json.dumps({ "name": "Carson Conway", "address": "42, Eos perferendis temp", "zipCode": "13463", "city": "Mollit laboris dolor", "phoneNumber": "1234567890" }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "name": "Carson Conway", "address": "42, Eos perferendis temp", "zipCode": "13463", "city": "Mollit laboris dolor", "phoneNumber": "1234567890" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/add-address', $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, "{ \"name\": \"Carson Conway\", \"address\": \"42, Eos perferendis temp\", \"zipCode\": \"13463\", \"city\": \"Mollit laboris dolor\", \"phoneNumber\": \"1234567890\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/add-address") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "name": "Carson Conway", "address": "42, Eos perferendis temp", "zipCode": "13463", "city": "Mollit laboris dolor", "phoneNumber": "1234567890" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/add-address", 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://api.infinitemlmsoftware.com/add-address" method := "POST" payload := strings.NewReader(`{ "name": "Carson Conway", "address": "42, Eos perferendis temp", "zipCode": "13463", "city": "Mollit laboris dolor", "phoneNumber": "1234567890" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/add-address"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"name\": \"Carson Conway\", \"address\": \"42, Eos perferendis temp\", \"zipCode\": \"13463\", \"city\": \"Mollit laboris dolor\", \"phoneNumber\": \"1234567890\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/change-default-address

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
newDefaultIdstring
PATCH/change-default-address?newDefaultId=5
curl --location --request PATCH 'https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Patch.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("PATCH", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('PATCH', 'https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5") .method("PATCH", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'PATCH', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5" method := "PATCH" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Patch, "https://api.infinitemlmsoftware.com/change-default-address?newDefaultId=5"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/delete-address

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
addressIdstring
defaultStatusstring
DELETE/delete-address?addressId=3&defaultStatus=1
curl --location --request DELETE 'https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Delete.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("DELETE", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('DELETE', 'https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1") .method("DELETE", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'DELETE', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1" method := "DELETE" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Delete, "https://api.infinitemlmsoftware.com/delete-address?addressId=3&defaultStatus=1"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/place-repurchase-order

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
paymentMethodnumber
repurchaseDataobject
epinarray
Q9Ta7Snk8Sstring
Q9Ta7Snk8Sstring
stripeTokenobject
idstring
objectstring
cardobject
idstring
objectstring
address_cityobject
address_countryobject
address_line1object
address_line1_checkobject
address_line2object
address_stateobject
address_zip_checkobject
brandstring
countrystring
cvc_checkstring
dynamic_last4object
exp_monthnumber
fundingstring
last4string
namestring
tokenization_methodobject
walletobject
client_ipstring
creatednumber
emailstring
livemodeboolean
typestring
usedboolean
transactionPasswordstring
POST/place-repurchase-order
curl --location 'https://api.infinitemlmsoftware.com/place-repurchase-order' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data-raw '{ "paymentMethod": 1, "repurchaseData": { "epin": [ "Q9Ta7Snk8S", "Q9Ta7Snk8S" ], "bankReceipt": "http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg", "stripeToken": { "id": "tok_1NXgp6KD7ZhA819wyg4dXB4G", "object": "token", "card": { "id": "card_1NXgp6KD7ZhA819wJggCwQfW", "object": "card", "address_city": {}, "address_country": {}, "address_line1": {}, "address_line1_check": {}, "address_line2": {}, "address_state": {}, "address_zip": {}, "address_zip_check": {}, "brand": "Visa", "country": "US", "cvc_check": "unchecked", "dynamic_last4": {}, "exp_month": 2, "exp_year": 2028, "funding": "credit", "last4": "1111", "name": "[email protected]", "tokenization_method": {}, "wallet": {} }, "client_ip": "103.103.174.106", "created": 1690274548, "email": "[email protected]", "livemode": false, "type": "card", "used": false } }, "transactionPassword": "12345678" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/place-repurchase-order") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "paymentMethod": 1, "repurchaseData": { "epin": [ "Q9Ta7Snk8S", "Q9Ta7Snk8S" ], "bankReceipt": "http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg", "stripeToken": { "id": "tok_1NXgp6KD7ZhA819wyg4dXB4G", "object": "token", "card": { "id": "card_1NXgp6KD7ZhA819wJggCwQfW", "object": "card", "address_city": {}, "address_country": {}, "address_line1": {}, "address_line1_check": {}, "address_line2": {}, "address_state": {}, "address_zip": {}, "address_zip_check": {}, "brand": "Visa", "country": "US", "cvc_check": "unchecked", "dynamic_last4": {}, "exp_month": 2, "exp_year": 2028, "funding": "credit", "last4": "1111", "name": "[email protected]", "tokenization_method": {}, "wallet": {} }, "client_ip": "103.103.174.106", "created": 1690274548, "email": "[email protected]", "livemode": false, "type": "card", "used": false } }, "transactionPassword": "12345678" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/place-repurchase-order" payload = json.dumps({ "paymentMethod": 1, "repurchaseData": { "epin": [ "Q9Ta7Snk8S", "Q9Ta7Snk8S" ], "bankReceipt": "http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg", "stripeToken": { "id": "tok_1NXgp6KD7ZhA819wyg4dXB4G", "object": "token", "card": { "id": "card_1NXgp6KD7ZhA819wJggCwQfW", "object": "card", "address_city": {}, "address_country": {}, "address_line1": {}, "address_line1_check": {}, "address_line2": {}, "address_state": {}, "address_zip": {}, "address_zip_check": {}, "brand": "Visa", "country": "US", "cvc_check": "unchecked", "dynamic_last4": {}, "exp_month": 2, "exp_year": 2028, "funding": "credit", "last4": "1111", "name": "[email protected]", "tokenization_method": {}, "wallet": {} }, "client_ip": "103.103.174.106", "created": 1690274548, "email": "[email protected]", "livemode": False, "type": "card", "used": False } }, "transactionPassword": "12345678" }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "paymentMethod": 1, "repurchaseData": { "epin": [ "Q9Ta7Snk8S", "Q9Ta7Snk8S" ], "bankReceipt": "http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg", "stripeToken": { "id": "tok_1NXgp6KD7ZhA819wyg4dXB4G", "object": "token", "card": { "id": "card_1NXgp6KD7ZhA819wJggCwQfW", "object": "card", "address_city": {}, "address_country": {}, "address_line1": {}, "address_line1_check": {}, "address_line2": {}, "address_state": {}, "address_zip": {}, "address_zip_check": {}, "brand": "Visa", "country": "US", "cvc_check": "unchecked", "dynamic_last4": {}, "exp_month": 2, "exp_year": 2028, "funding": "credit", "last4": "1111", "name": "[email protected]", "tokenization_method": {}, "wallet": {} }, "client_ip": "103.103.174.106", "created": 1690274548, "email": "[email protected]", "livemode": false, "type": "card", "used": false } }, "transactionPassword": "12345678" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/place-repurchase-order', $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, "{ \"paymentMethod\": 1, \"repurchaseData\": { \"epin\": [ \"Q9Ta7Snk8S\", \"Q9Ta7Snk8S\" ], \"bankReceipt\": \"http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg\", \"stripeToken\": { \"id\": \"tok_1NXgp6KD7ZhA819wyg4dXB4G\", \"object\": \"token\", \"card\": { \"id\": \"card_1NXgp6KD7ZhA819wJggCwQfW\", \"object\": \"card\", \"address_city\": {}, \"address_country\": {}, \"address_line1\": {}, \"address_line1_check\": {}, \"address_line2\": {}, \"address_state\": {}, \"address_zip\": {}, \"address_zip_check\": {}, \"brand\": \"Visa\", \"country\": \"US\", \"cvc_check\": \"unchecked\", \"dynamic_last4\": {}, \"exp_month\": 2, \"exp_year\": 2028, \"funding\": \"credit\", \"last4\": \"1111\", \"name\": \"[email protected]\", \"tokenization_method\": {}, \"wallet\": {} }, \"client_ip\": \"103.103.174.106\", \"created\": 1690274548, \"email\": \"[email protected]\", \"livemode\": false, \"type\": \"card\", \"used\": false } }, \"transactionPassword\": \"12345678\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/place-repurchase-order") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "paymentMethod": 1, "repurchaseData": { "epin": [ "Q9Ta7Snk8S", "Q9Ta7Snk8S" ], "bankReceipt": "http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg", "stripeToken": { "id": "tok_1NXgp6KD7ZhA819wyg4dXB4G", "object": "token", "card": { "id": "card_1NXgp6KD7ZhA819wJggCwQfW", "object": "card", "address_city": {}, "address_country": {}, "address_line1": {}, "address_line1_check": {}, "address_line2": {}, "address_state": {}, "address_zip": {}, "address_zip_check": {}, "brand": "Visa", "country": "US", "cvc_check": "unchecked", "dynamic_last4": {}, "exp_month": 2, "exp_year": 2028, "funding": "credit", "last4": "1111", "name": "[email protected]", "tokenization_method": {}, "wallet": {} }, "client_ip": "103.103.174.106", "created": 1690274548, "email": "[email protected]", "livemode": false, "type": "card", "used": false } }, "transactionPassword": "12345678" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/place-repurchase-order", 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://api.infinitemlmsoftware.com/place-repurchase-order" method := "POST" payload := strings.NewReader(`{ "paymentMethod": 1, "repurchaseData": { "epin": [ "Q9Ta7Snk8S", "Q9Ta7Snk8S" ], "bankReceipt": "http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg", "stripeToken": { "id": "tok_1NXgp6KD7ZhA819wyg4dXB4G", "object": "token", "card": { "id": "card_1NXgp6KD7ZhA819wJggCwQfW", "object": "card", "address_city": {}, "address_country": {}, "address_line1": {}, "address_line1_check": {}, "address_line2": {}, "address_state": {}, "address_zip": {}, "address_zip_check": {}, "brand": "Visa", "country": "US", "cvc_check": "unchecked", "dynamic_last4": {}, "exp_month": 2, "exp_year": 2028, "funding": "credit", "last4": "1111", "name": "[email protected]", "tokenization_method": {}, "wallet": {} }, "client_ip": "103.103.174.106", "created": 1690274548, "email": "[email protected]", "livemode": false, "type": "card", "used": false } }, "transactionPassword": "12345678" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/place-repurchase-order"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"paymentMethod\": 1, \"repurchaseData\": { \"epin\": [ \"Q9Ta7Snk8S\", \"Q9Ta7Snk8S\" ], \"bankReceipt\": \"http://192.168.9.19:60/uploads/images/bank/cat03-1689343510559.jpeg\", \"stripeToken\": { \"id\": \"tok_1NXgp6KD7ZhA819wyg4dXB4G\", \"object\": \"token\", \"card\": { \"id\": \"card_1NXgp6KD7ZhA819wJggCwQfW\", \"object\": \"card\", \"address_city\": {}, \"address_country\": {}, \"address_line1\": {}, \"address_line1_check\": {}, \"address_line2\": {}, \"address_state\": {}, \"address_zip\": {}, \"address_zip_check\": {}, \"brand\": \"Visa\", \"country\": \"US\", \"cvc_check\": \"unchecked\", \"dynamic_last4\": {}, \"exp_month\": 2, \"exp_year\": 2028, \"funding\": \"credit\", \"last4\": \"1111\", \"name\": \"[email protected]\", \"tokenization_method\": {}, \"wallet\": {} }, \"client_ip\": \"103.103.174.106\", \"created\": 1690274548, \"email\": \"[email protected]\", \"livemode\": false, \"type\": \"card\", \"used\": false } }, \"transactionPassword\": \"12345678\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/payment-gateway-key

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
paymentMethodstring
GET/payment-gateway-key?paymentMethod=5
curl --location 'https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/payment-gateway-key?paymentMethod=5"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/purchase_invoice

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
paymentMethodstring
GET/purchase_invoice?orderId=48
curl --location 'https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/purchase-invoice?orderId=48"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/upload-bank-receipt

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
typestring
optionsstring
Body Parameters
filefile
POST/upload-bank-receipt?orderId=48
curl --location --request POST 'https://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration%2Crepurchase%2C%20upgrade%2Crenewal' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration,repurchase, upgrade,renewal") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" form_data = [] request.set_form form_data, 'multipart/form-data' response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration,repurchase, upgrade,renewal" payload = {} files={} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("POST", url, headers=headers, data=payload, files=files) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration,repurchase, upgrade,renewal', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); MediaType JSON = MediaType.parse("application/json; charset=utf-8"); RequestBody body = RequestBody.create(JSON, "{}"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration,repurchase, upgrade,renewal") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var formdata = new FormData(); var requestOptions = { method: 'POST', headers: myHeaders, body: formdata, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration,repurchase, upgrade,renewal", 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://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration%2Crepurchase%2C%20upgrade%2Crenewal" method := "POST" payload := &bytes.Buffer{} writer := multipart.NewWriter(payload) 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.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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://api.infinitemlmsoftware.com/upload-bank-receipt?type=repurchase&options=registration,repurchase, upgrade,renewal"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());{ "title": "Gun List API", "description": "API for managing gun list", "base_url": "http://localhost:3000/api", "endpoints": [ { "method": "GET", "route": "/guns", "description": "Get all guns", "examples": { "javascript": "fetch('http://localhost:3000/api/guns').then(res => res.json()).then(data => console.log(data));", "python": "import requests\nresponse = requests.get('http://localhost:3000/api/guns')\nprint(response.json())", "java": "HttpRequest request = HttpRequest.newBuilder().uri(URI.create(\"http://localhost:3000/api/guns\")).build();", "php": "$response = file_get_contents('http://localhost:3000/api/guns'); echo $response;" } }, { "method": "POST", "route": "/guns", "description": "Add a new gun", "request_body": { "name": "M16", "caliber": "5.56mm" }, "response": { "message": "Gun added successfully" }, "examples": { "javascript": "fetch('http://localhost:3000/api/guns', {method: 'POST', body: JSON.stringify({name: 'M16', caliber: '5.56mm'})})", "python": "requests.post('http://localhost:3000/api/guns', json={'name': 'M16', 'caliber': '5.56mm'})", "java": "HttpRequest request = HttpRequest.newBuilder().POST(HttpRequest.BodyPublishers.ofString('{\"name\": \"M16\", \"caliber\": \"5.56mm\"}')).uri(URI.create(\"http://localhost:3000/api/guns\")).build();", "php": "$options = ['http' => ['method' => 'POST', 'content' => json_encode(['name' => 'M16', 'caliber' => '5.56mm'])]];\n$context = stream_context_create($options);\n$response = file_get_contents('http://localhost:3000/api/guns', false, $context);" } } ] }

/check-epin-validity

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
paymentMethodstring
epinDataarray
9TS8H2AIJCarray
WytObGbq73ZHEarray
fzLj_lHsof5RTarray
totalCartnumber
GET/check-epin-validity
curl --location --request GET 'https://api.infinitemlmsoftware.com/check-epin-validity' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "paymentMethod": "repurchase", "epinData": [ "9TS8H2AIJC", "WytObGbq73ZHE", "fzLj_lHsof5RT" ], "totalCart": 204 }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/check-epin-validity") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "paymentMethod": "repurchase", "epinData": [ "9TS8H2AIJC", "WytObGbq73ZHE", "fzLj_lHsof5RT" ], "totalCart": 204 }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/check-epin-validity" payload = json.dumps({ "paymentMethod": "repurchase", "epinData": [ "9TS8H2AIJC", "WytObGbq73ZHE", "fzLj_lHsof5RT" ], "totalCart": 204 }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "paymentMethod": "repurchase", "epinData": [ "9TS8H2AIJC", "WytObGbq73ZHE", "fzLj_lHsof5RT" ], "totalCart": 204 }'; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/check-epin-validity', $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, "{ \"paymentMethod\": \"repurchase\", \"epinData\": [ \"9TS8H2AIJC\", \"WytObGbq73ZHE\", \"fzLj_lHsof5RT\" ], \"totalCart\": 204 }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/check-epin-validity") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "paymentMethod": "repurchase", "epinData": [ "9TS8H2AIJC", "WytObGbq73ZHE", "fzLj_lHsof5RT" ], "totalCart": 204 }); var requestOptions = { method: 'GET', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/check-epin-validity", 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://api.infinitemlmsoftware.com/check-epin-validity" method := "GET" payload := strings.NewReader(`{ "paymentMethod": "repurchase", "epinData": [ "9TS8H2AIJC", "WytObGbq73ZHE", "fzLj_lHsof5RT" ], "totalCart": 204 }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/check-epin-validity"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"paymentMethod\": \"repurchase\", \"epinData\": [ \"9TS8H2AIJC\", \"WytObGbq73ZHE\", \"fzLj_lHsof5RT\" ], \"totalCart\": 204 }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

mobileApp

/app/dashboard

Header Parameters
api-keystring
access-tokenstring
GET/app/dashboard
curl --location 'https://api.infinitemlmsoftware.com/app/dashboard' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/app/app_info") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "387245a5a919ea2071cc406b10b89d4685e5cc8e" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/app/dashboard" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/app/dashboard', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/app/dashboard") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/app/dashboard", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/app/dashboard" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/app/dashboard"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/app/app_info

Header Parameters
api-keystring
access-tokenstring
GET/app/app_info
curl --location 'https://api.infinitemlmsoftware.com/app/app_info' \ --header 'api-key: 387245a5a919ea2071cc406b10b89d4685e5cc8e' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/app/app_info") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "387245a5a919ea2071cc406b10b89d4685e5cc8e" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/app/app_info" payload = {} headers = { 'api-key': '387245a5a919ea2071cc406b10b89d4685e5cc8e', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '387245a5a919ea2071cc406b10b89d4685e5cc8e', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/app/app_info', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/app/app_info") .method("GET", body) .addHeader("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/app/app_info", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/app/app_info" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/app/app_info"); request.Headers.Add("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Tools

/all-news

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/all-news
curl --location 'https://api.infinitemlmsoftware.com/all-news' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/all-news") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/all-news" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/all-news', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/all-news") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/all-news", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/all-news" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/all-news"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get-news-article

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
newsIdstring
GET/get-news-article
curl --location 'https://api.infinitemlmsoftware.com/get-news-article?newsId=5' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-news-article?newsId=5") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/get-news-article?newsId=5" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-news-article?newsId=5', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-news-article?newsId=5") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-news-article?newsId=5", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-news-article?newsId=5" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/get-news-article?newsId=5"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/get-faqs

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
pagestring
perPagestring
GET/get-faqs
curl --location 'https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/get-faqs?page=1&perPage=10"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Upgrade

/get-upgrade-products

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-upgrade-products
curl --location 'https://api.infinitemlmsoftware.com/get-upgrade-products' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-upgrade-products") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-upgrade-products" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-upgrade-products', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-upgrade-products") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-upgrade-products", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-upgrade-products" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-upgrade-products"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/upgrade

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
paymentMethodstring
upgradeDataobject
oldProductIdnumber
upgradeProductIdnumber
bankReceiptstring
epinarray
NxvwboRs-QjUFstring
p3bH98vak00GBstring
mYkUKrst8hSBFstring
stripeTokenstring
paypalTokenstring
POST/upgrade
curl --location 'https://api.infinitemlmsoftware.com/upgrade' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "paymentMethod": 2, "upgradeData": { "oldProductId": 1, "upgradeProductId": 2, "bankReceipt": "abc", "epin": [ "NxvwboRs-QjUF", "p3bH98vak00GB", "mYkUKrst8hSBF" ], "stripeToken": "abc", "paypalToken": "abc" }, "transactionPassword": "12345678" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/upgrade") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "paymentMethod": 2, "upgradeData": { "oldProductId": 1, "upgradeProductId": 2, "bankReceipt": "abc", "epin": [ "NxvwboRs-QjUF", "p3bH98vak00GB", "mYkUKrst8hSBF" ], "stripeToken": "abc", "paypalToken": "abc" }, "transactionPassword": "12345678" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/upgrade" payload = json.dumps({ "paymentMethod": 2, "upgradeData": { "oldProductId": 1, "upgradeProductId": 2, "bankReceipt": "abc", "epin": [ "NxvwboRs-QjUF", "p3bH98vak00GB", "mYkUKrst8hSBF" ], "stripeToken": "abc", "paypalToken": "abc" }, "transactionPassword": "12345678" }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "paymentMethod": 2, "upgradeData": { "oldProductId": 1, "upgradeProductId": 2, "bankReceipt": "abc", "epin": [ "NxvwboRs-QjUF", "p3bH98vak00GB", "mYkUKrst8hSBF" ], "stripeToken": "abc", "paypalToken": "abc" }, "transactionPassword": "12345678" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/upgrade', $headers, $body); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-news-article?newsId=5") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "paymentMethod": 2, "upgradeData": { "oldProductId": 1, "upgradeProductId": 2, "bankReceipt": "abc", "epin": [ "NxvwboRs-QjUF", "p3bH98vak00GB", "mYkUKrst8hSBF" ], "stripeToken": "abc", "paypalToken": "abc" }, "transactionPassword": "12345678" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/upgrade", 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://api.infinitemlmsoftware.com/upgrade" method := "POST" payload := strings.NewReader(`{ "paymentMethod": 2, "upgradeData": { "oldProductId": 1, "upgradeProductId": 2, "bankReceipt": "abc", "epin": [ "NxvwboRs-QjUF", "p3bH98vak00GB", "mYkUKrst8hSBF" ], "stripeToken": "abc", "paypalToken": "abc" }, "transactionPassword": "12345678" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/upgrade"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"paymentMethod\": 2, \"upgradeData\": { \"oldProductId\": 1, \"upgradeProductId\": 2, \"bankReceipt\": \"abc\", \"epin\": [ \"NxvwboRs-QjUF\", \"p3bH98vak00GB\", \"mYkUKrst8hSBF\" ], \"stripeToken\": \"abc\", \"paypalToken\": \"abc\" }, \"transactionPassword\": \"12345678\" }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Subscription

/get-subscription-details

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-subscription-details
curl --location 'https://api.infinitemlmsoftware.com/get-subscription-details' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-subscription-details") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/get-subscription-details" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-subscription-details', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-subscription-details") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-subscription-details", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-subscription-details" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-subscription-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/renew-subscription

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
productIdnumber
paymentMethodnumber
subscriptionDataobject
renewalPricenumber
epinarray
stripeTokenstring
transactionPasswordstring
POST/renew-subscription
curl --location 'https://api.infinitemlmsoftware.com/renew-subscription' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "productId": 1, "paymentMethod": 3, "subscriptionData": { "renewalPrice": 100, "epin": [], "stripeToken": "abc" }, "transactionPassword": "12345678" }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/renew-subscription") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "productId": 1, "paymentMethod": 3, "subscriptionData": { "renewalPrice": 100, "epin": [], "stripeToken": "abc" }, "transactionPassword": "12345678" }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/renew-subscription" payload = json.dumps({ "productId": 1, "paymentMethod": 3, "subscriptionData": { "renewalPrice": 100, "epin": [], "stripeToken": "abc" }, "transactionPassword": "12345678" }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "productId": 1, "paymentMethod": 3, "subscriptionData": { "renewalPrice": 100, "epin": [], "stripeToken": "abc" }, "transactionPassword": "12345678" }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/renew-subscription', $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, "{ \"productId\": 1, \"paymentMethod\": 3, \"subscriptionData\": { \"renewalPrice\": 100, \"epin\": [], \"stripeToken\": \"abc\" }, \"transactionPassword\": \"12345678\" }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/renew-subscription") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "productId": 1, "paymentMethod": 3, "subscriptionData": { "renewalPrice": 100, "epin": [], "stripeToken": "abc" }, "transactionPassword": "12345678" }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/renew-subscription", 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://api.infinitemlmsoftware.com/renew-subscription" method := "POST" payload := strings.NewReader(`{ "productId": 1, "paymentMethod": 3, "subscriptionData": { "renewalPrice": 100, "epin": [], "stripeToken": "abc" }, "transactionPassword": "12345678" }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/get-subscription-details"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/paypal-autosubscription

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
idstring
create_timestring
event_typestring
event_versionstring
resource_typestring
resource_versionstring
resource_versionstring
summarystring
resourceobject
idstring
statusstring
status_update_timestring
plan_idstring
start_timestring
quantitystring
shipping_amountobject
currency_codestring
valuestring
subscriberobject
nameobject
given_namestring
surnamestring
email_addressstring
shipping_addressobject
nameobject
full_namestring
addressobject
address_line_1string
address_line_2string
admin_area_2string
admin_area_1string
postal_codestring
country_codestring
auto_renewalboolean
billing_infoobject
outstanding_balanceobject
currency_codestring
valuestring
cycle_executionsarray
tenure_typestring
sequencenumber
cycles_completednumber
cycles_remainingnumber
current_pricing_scheme_versionnumber
last_paymentobject
amountobject
currency_codestring
valuestring
timestring
next_billing_timestring
final_payment_timestring
failed_payments_countnumber
create_timestring
update_timestring
transactionPasswordstring
linksarray
POST/paypal-autosubscription
curl --location 'https://api.infinitemlmsoftware.com/paypal-autosubscription' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data-raw '{ "id": "WH-TY567577T725889R5-1E6T55435R66166TR", "create_time": "2018-19-12T22:20:32.000Z", "event_type": "BILLING.SUBSCRIPTION.CREATED", "event_version": "1.0", "resource_type": "subscription", "resource_version": "2.0", "summary": "A billing subscription was created.", "resource": { "id": "I-BW452GLLEP1G", "status": "APPROVAL_PENDING", "status_update_time": "2018-12-10T21:20:49Z", "plan_id": "P-5ML4271244454362WXNWU5NQ", "start_time": "2018-11-01T00:00:00Z", "quantity": "20", "shipping_amount": { "currency_code": "USD", "value": "10.00" }, "subscriber": { "name": { "given_name": "John", "surname": "Doe" }, "email_address": "[email protected]", "shipping_address": { "name": { "full_name": "John Doe" }, "address": { "address_line_1": "2211 N First Street", "address_line_2": "Building 17", "admin_area_2": "San Jose", "admin_area_1": "CA", "postal_code": "95131", "country_code": "US" } } }, "auto_renewal": true, "billing_info": { "outstanding_balance": { "currency_code": "USD", "value": "10.00" }, "cycle_executions": [ { "tenure_type": "TRIAL", "sequence": 1, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 }, { "tenure_type": "REGULAR", "sequence": 2, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 } ], "last_payment": { "amount": { "currency_code": "USD", "value": "500.00" }, "time": "2018-12-01T01:20:49Z" }, "next_billing_time": "2019-01-01T00:20:49Z", "final_payment_time": "2020-01-01T00:20:49Z", "failed_payments_count": 2 }, "create_time": "2018-12-10T21:20:49Z", "update_time": "2018-12-10T21:20:49Z", "links": [ { "href": "https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J", "rel": "approve", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "edit", "method": "PATCH" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate", "rel": "activate", "method": "POST" } ] }, "links": [ { "href": "https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend", "rel": "resend", "method": "POST" } ] }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/paypal-autosubscription") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "id": "WH-TY567577T725889R5-1E6T55435R66166TR", "create_time": "2018-19-12T22:20:32.000Z", "event_type": "BILLING.SUBSCRIPTION.CREATED", "event_version": "1.0", "resource_type": "subscription", "resource_version": "2.0", "summary": "A billing subscription was created.", "resource": { "id": "I-BW452GLLEP1G", "status": "APPROVAL_PENDING", "status_update_time": "2018-12-10T21:20:49Z", "plan_id": "P-5ML4271244454362WXNWU5NQ", "start_time": "2018-11-01T00:00:00Z", "quantity": "20", "shipping_amount": { "currency_code": "USD", "value": "10.00" }, "subscriber": { "name": { "given_name": "John", "surname": "Doe" }, "email_address": "[email protected]", "shipping_address": { "name": { "full_name": "John Doe" }, "address": { "address_line_1": "2211 N First Street", "address_line_2": "Building 17", "admin_area_2": "San Jose", "admin_area_1": "CA", "postal_code": "95131", "country_code": "US" } } }, "auto_renewal": true, "billing_info": { "outstanding_balance": { "currency_code": "USD", "value": "10.00" }, "cycle_executions": [ { "tenure_type": "TRIAL", "sequence": 1, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 }, { "tenure_type": "REGULAR", "sequence": 2, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 } ], "last_payment": { "amount": { "currency_code": "USD", "value": "500.00" }, "time": "2018-12-01T01:20:49Z" }, "next_billing_time": "2019-01-01T00:20:49Z", "final_payment_time": "2020-01-01T00:20:49Z", "failed_payments_count": 2 }, "create_time": "2018-12-10T21:20:49Z", "update_time": "2018-12-10T21:20:49Z", "links": [ { "href": "https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J", "rel": "approve", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "edit", "method": "PATCH" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate", "rel": "activate", "method": "POST" } ] }, "links": [ { "href": "https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend", "rel": "resend", "method": "POST" } ] }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/paypal-autosubscription" payload = json.dumps({ "id": "WH-TY567577T725889R5-1E6T55435R66166TR", "create_time": "2018-19-12T22:20:32.000Z", "event_type": "BILLING.SUBSCRIPTION.CREATED", "event_version": "1.0", "resource_type": "subscription", "resource_version": "2.0", "summary": "A billing subscription was created.", "resource": { "id": "I-BW452GLLEP1G", "status": "APPROVAL_PENDING", "status_update_time": "2018-12-10T21:20:49Z", "plan_id": "P-5ML4271244454362WXNWU5NQ", "start_time": "2018-11-01T00:00:00Z", "quantity": "20", "shipping_amount": { "currency_code": "USD", "value": "10.00" }, "subscriber": { "name": { "given_name": "John", "surname": "Doe" }, "email_address": "[email protected]", "shipping_address": { "name": { "full_name": "John Doe" }, "address": { "address_line_1": "2211 N First Street", "address_line_2": "Building 17", "admin_area_2": "San Jose", "admin_area_1": "CA", "postal_code": "95131", "country_code": "US" } } }, "auto_renewal": True, "billing_info": { "outstanding_balance": { "currency_code": "USD", "value": "10.00" }, "cycle_executions": [ { "tenure_type": "TRIAL", "sequence": 1, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 }, { "tenure_type": "REGULAR", "sequence": 2, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 } ], "last_payment": { "amount": { "currency_code": "USD", "value": "500.00" }, "time": "2018-12-01T01:20:49Z" }, "next_billing_time": "2019-01-01T00:20:49Z", "final_payment_time": "2020-01-01T00:20:49Z", "failed_payments_count": 2 }, "create_time": "2018-12-10T21:20:49Z", "update_time": "2018-12-10T21:20:49Z", "links": [ { "href": "https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J", "rel": "approve", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "edit", "method": "PATCH" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate", "rel": "activate", "method": "POST" } ] }, "links": [ { "href": "https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend", "rel": "resend", "method": "POST" } ] }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "id": "WH-TY567577T725889R5-1E6T55435R66166TR", "create_time": "2018-19-12T22:20:32.000Z", "event_type": "BILLING.SUBSCRIPTION.CREATED", "event_version": "1.0", "resource_type": "subscription", "resource_version": "2.0", "summary": "A billing subscription was created.", "resource": { "id": "I-BW452GLLEP1G", "status": "APPROVAL_PENDING", "status_update_time": "2018-12-10T21:20:49Z", "plan_id": "P-5ML4271244454362WXNWU5NQ", "start_time": "2018-11-01T00:00:00Z", "quantity": "20", "shipping_amount": { "currency_code": "USD", "value": "10.00" }, "subscriber": { "name": { "given_name": "John", "surname": "Doe" }, "email_address": "[email protected]", "shipping_address": { "name": { "full_name": "John Doe" }, "address": { "address_line_1": "2211 N First Street", "address_line_2": "Building 17", "admin_area_2": "San Jose", "admin_area_1": "CA", "postal_code": "95131", "country_code": "US" } } }, "auto_renewal": true, "billing_info": { "outstanding_balance": { "currency_code": "USD", "value": "10.00" }, "cycle_executions": [ { "tenure_type": "TRIAL", "sequence": 1, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 }, { "tenure_type": "REGULAR", "sequence": 2, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 } ], "last_payment": { "amount": { "currency_code": "USD", "value": "500.00" }, "time": "2018-12-01T01:20:49Z" }, "next_billing_time": "2019-01-01T00:20:49Z", "final_payment_time": "2020-01-01T00:20:49Z", "failed_payments_count": 2 }, "create_time": "2018-12-10T21:20:49Z", "update_time": "2018-12-10T21:20:49Z", "links": [ { "href": "https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J", "rel": "approve", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "edit", "method": "PATCH" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate", "rel": "activate", "method": "POST" } ] }, "links": [ { "href": "https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend", "rel": "resend", "method": "POST" } ] }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/paypal-autosubscription', $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, "{ \"id\": \"WH-TY567577T725889R5-1E6T55435R66166TR\", \"create_time\": \"2018-19-12T22:20:32.000Z\", \"event_type\": \"BILLING.SUBSCRIPTION.CREATED\", \"event_version\": \"1.0\", \"resource_type\": \"subscription\", \"resource_version\": \"2.0\", \"summary\": \"A billing subscription was created.\", \"resource\": { \"id\": \"I-BW452GLLEP1G\", \"status\": \"APPROVAL_PENDING\", \"status_update_time\": \"2018-12-10T21:20:49Z\", \"plan_id\": \"P-5ML4271244454362WXNWU5NQ\", \"start_time\": \"2018-11-01T00:00:00Z\", \"quantity\": \"20\", \"shipping_amount\": { \"currency_code\": \"USD\", \"value\": \"10.00\" }, \"subscriber\": { \"name\": { \"given_name\": \"John\", \"surname\": \"Doe\" }, \"email_address\": \"[email protected]\", \"shipping_address\": { \"name\": { \"full_name\": \"John Doe\" }, \"address\": { \"address_line_1\": \"2211 N First Street\", \"address_line_2\": \"Building 17\", \"admin_area_2\": \"San Jose\", \"admin_area_1\": \"CA\", \"postal_code\": \"95131\", \"country_code\": \"US\" } } }, \"auto_renewal\": true, \"billing_info\": { \"outstanding_balance\": { \"currency_code\": \"USD\", \"value\": \"10.00\" }, \"cycle_executions\": [ { \"tenure_type\": \"TRIAL\", \"sequence\": 1, \"cycles_completed\": 1, \"cycles_remaining\": 0, \"current_pricing_scheme_version\": 1 }, { \"tenure_type\": \"REGULAR\", \"sequence\": 2, \"cycles_completed\": 1, \"cycles_remaining\": 0, \"current_pricing_scheme_version\": 1 } ], \"last_payment\": { \"amount\": { \"currency_code\": \"USD\", \"value\": \"500.00\" }, \"time\": \"2018-12-01T01:20:49Z\" }, \"next_billing_time\": \"2019-01-01T00:20:49Z\", \"final_payment_time\": \"2020-01-01T00:20:49Z\", \"failed_payments_count\": 2 }, \"create_time\": \"2018-12-10T21:20:49Z\", \"update_time\": \"2018-12-10T21:20:49Z\", \"links\": [ { \"href\": \"https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J\", \"rel\": \"approve\", \"method\": \"GET\" }, { \"href\": \"https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G\", \"rel\": \"self\", \"method\": \"GET\" }, { \"href\": \"https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G\", \"rel\": \"edit\", \"method\": \"PATCH\" }, { \"href\": \"https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate\", \"rel\": \"activate\", \"method\": \"POST\" } ] }, \"links\": [ { \"href\": \"https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR\", \"rel\": \"self\", \"method\": \"GET\" }, { \"href\": \"https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend\", \"rel\": \"resend\", \"method\": \"POST\" } ] }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/paypal-autosubscription") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "id": "WH-TY567577T725889R5-1E6T55435R66166TR", "create_time": "2018-19-12T22:20:32.000Z", "event_type": "BILLING.SUBSCRIPTION.CREATED", "event_version": "1.0", "resource_type": "subscription", "resource_version": "2.0", "summary": "A billing subscription was created.", "resource": { "id": "I-BW452GLLEP1G", "status": "APPROVAL_PENDING", "status_update_time": "2018-12-10T21:20:49Z", "plan_id": "P-5ML4271244454362WXNWU5NQ", "start_time": "2018-11-01T00:00:00Z", "quantity": "20", "shipping_amount": { "currency_code": "USD", "value": "10.00" }, "subscriber": { "name": { "given_name": "John", "surname": "Doe" }, "email_address": "[email protected]", "shipping_address": { "name": { "full_name": "John Doe" }, "address": { "address_line_1": "2211 N First Street", "address_line_2": "Building 17", "admin_area_2": "San Jose", "admin_area_1": "CA", "postal_code": "95131", "country_code": "US" } } }, "auto_renewal": true, "billing_info": { "outstanding_balance": { "currency_code": "USD", "value": "10.00" }, "cycle_executions": [ { "tenure_type": "TRIAL", "sequence": 1, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 }, { "tenure_type": "REGULAR", "sequence": 2, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 } ], "last_payment": { "amount": { "currency_code": "USD", "value": "500.00" }, "time": "2018-12-01T01:20:49Z" }, "next_billing_time": "2019-01-01T00:20:49Z", "final_payment_time": "2020-01-01T00:20:49Z", "failed_payments_count": 2 }, "create_time": "2018-12-10T21:20:49Z", "update_time": "2018-12-10T21:20:49Z", "links": [ { "href": "https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J", "rel": "approve", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "edit", "method": "PATCH" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate", "rel": "activate", "method": "POST" } ] }, "links": [ { "href": "https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend", "rel": "resend", "method": "POST" } ] }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/paypal-autosubscription", 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://api.infinitemlmsoftware.com/paypal-autosubscription" method := "POST" payload := strings.NewReader(`{ "id": "WH-TY567577T725889R5-1E6T55435R66166TR", "create_time": "2018-19-12T22:20:32.000Z", "event_type": "BILLING.SUBSCRIPTION.CREATED", "event_version": "1.0", "resource_type": "subscription", "resource_version": "2.0", "summary": "A billing subscription was created.", "resource": { "id": "I-BW452GLLEP1G", "status": "APPROVAL_PENDING", "status_update_time": "2018-12-10T21:20:49Z", "plan_id": "P-5ML4271244454362WXNWU5NQ", "start_time": "2018-11-01T00:00:00Z", "quantity": "20", "shipping_amount": { "currency_code": "USD", "value": "10.00" }, "subscriber": { "name": { "given_name": "John", "surname": "Doe" }, "email_address": "[email protected]", "shipping_address": { "name": { "full_name": "John Doe" }, "address": { "address_line_1": "2211 N First Street", "address_line_2": "Building 17", "admin_area_2": "San Jose", "admin_area_1": "CA", "postal_code": "95131", "country_code": "US" } } }, "auto_renewal": true, "billing_info": { "outstanding_balance": { "currency_code": "USD", "value": "10.00" }, "cycle_executions": [ { "tenure_type": "TRIAL", "sequence": 1, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 }, { "tenure_type": "REGULAR", "sequence": 2, "cycles_completed": 1, "cycles_remaining": 0, "current_pricing_scheme_version": 1 } ], "last_payment": { "amount": { "currency_code": "USD", "value": "500.00" }, "time": "2018-12-01T01:20:49Z" }, "next_billing_time": "2019-01-01T00:20:49Z", "final_payment_time": "2020-01-01T00:20:49Z", "failed_payments_count": 2 }, "create_time": "2018-12-10T21:20:49Z", "update_time": "2018-12-10T21:20:49Z", "links": [ { "href": "https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J", "rel": "approve", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G", "rel": "edit", "method": "PATCH" }, { "href": "https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate", "rel": "activate", "method": "POST" } ] }, "links": [ { "href": "https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR", "rel": "self", "method": "GET" }, { "href": "https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend", "rel": "resend", "method": "POST" } ] }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/paypal-autosubscription"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"id\": \"WH-TY567577T725889R5-1E6T55435R66166TR\", \"create_time\": \"2018-19-12T22:20:32.000Z\", \"event_type\": \"BILLING.SUBSCRIPTION.CREATED\", \"event_version\": \"1.0\", \"resource_type\": \"subscription\", \"resource_version\": \"2.0\", \"summary\": \"A billing subscription was created.\", \"resource\": { \"id\": \"I-BW452GLLEP1G\", \"status\": \"APPROVAL_PENDING\", \"status_update_time\": \"2018-12-10T21:20:49Z\", \"plan_id\": \"P-5ML4271244454362WXNWU5NQ\", \"start_time\": \"2018-11-01T00:00:00Z\", \"quantity\": \"20\", \"shipping_amount\": { \"currency_code\": \"USD\", \"value\": \"10.00\" }, \"subscriber\": { \"name\": { \"given_name\": \"John\", \"surname\": \"Doe\" }, \"email_address\": \"[email protected]\", \"shipping_address\": { \"name\": { \"full_name\": \"John Doe\" }, \"address\": { \"address_line_1\": \"2211 N First Street\", \"address_line_2\": \"Building 17\", \"admin_area_2\": \"San Jose\", \"admin_area_1\": \"CA\", \"postal_code\": \"95131\", \"country_code\": \"US\" } } }, \"auto_renewal\": true, \"billing_info\": { \"outstanding_balance\": { \"currency_code\": \"USD\", \"value\": \"10.00\" }, \"cycle_executions\": [ { \"tenure_type\": \"TRIAL\", \"sequence\": 1, \"cycles_completed\": 1, \"cycles_remaining\": 0, \"current_pricing_scheme_version\": 1 }, { \"tenure_type\": \"REGULAR\", \"sequence\": 2, \"cycles_completed\": 1, \"cycles_remaining\": 0, \"current_pricing_scheme_version\": 1 } ], \"last_payment\": { \"amount\": { \"currency_code\": \"USD\", \"value\": \"500.00\" }, \"time\": \"2018-12-01T01:20:49Z\" }, \"next_billing_time\": \"2019-01-01T00:20:49Z\", \"final_payment_time\": \"2020-01-01T00:20:49Z\", \"failed_payments_count\": 2 }, \"create_time\": \"2018-12-10T21:20:49Z\", \"update_time\": \"2018-12-10T21:20:49Z\", \"links\": [ { \"href\": \"https://www.paypal.com/webapps/billing/subscriptions?ba_token=BA-4GH39689T3856352J\", \"rel\": \"approve\", \"method\": \"GET\" }, { \"href\": \"https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G\", \"rel\": \"self\", \"method\": \"GET\" }, { \"href\": \"https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G\", \"rel\": \"edit\", \"method\": \"PATCH\" }, { \"href\": \"https://api.paypal.com/v1/billing/subscriptions/I-BW452GLLEP1G/activate\", \"rel\": \"activate\", \"method\": \"POST\" } ] }, \"links\": [ { \"href\": \"https://api.paypal.com/v1/notifications/webhooks-events/TY567577T725889R5-1E6T55435R66166TR\", \"rel\": \"self\", \"method\": \"GET\" }, { \"href\": \"https://api.paypal.com/v1/notifications/webhooks-events/WH-TY567577T725889R5-1E6T55435R66166TR/resend\", \"rel\": \"resend\", \"method\": \"POST\" } ] }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/subscription-history-report

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
planIdstring
dataobject
orderIDstring
subscriptionIDstring
facilitatorAccessTokenstring
paymentSourcestring
POST/subscription-history-report
curl --location --request GET 'https://api.infinitemlmsoftware.com/subscription-history-report' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "planId": "P-0C686669RW515132KMVBWDKQ", "data": { "orderID": "5KG37465D8302663E", "subscriptionID": "I-W59RR0145VJW", "facilitatorAccessToken": "A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg", "paymentSource": "paypal" } }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/subscription-history-report") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "planId": "P-0C686669RW515132KMVBWDKQ", "data": { "orderID": "5KG37465D8302663E", "subscriptionID": "I-W59RR0145VJW", "facilitatorAccessToken": "A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg", "paymentSource": "paypal" } }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/subscription-history-report" payload = json.dumps({ "planId": "P-0C686669RW515132KMVBWDKQ", "data": { "orderID": "5KG37465D8302663E", "subscriptionID": "I-W59RR0145VJW", "facilitatorAccessToken": "A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg", "paymentSource": "paypal" } }) headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "planId": "P-0C686669RW515132KMVBWDKQ", "data": { "orderID": "5KG37465D8302663E", "subscriptionID": "I-W59RR0145VJW", "facilitatorAccessToken": "A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg", "paymentSource": "paypal" } }'; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/subscription-history-report', $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, "{ \"planId\": \"P-0C686669RW515132KMVBWDKQ\", \"data\": { \"orderID\": \"5KG37465D8302663E\", \"subscriptionID\": \"I-W59RR0145VJW\", \"facilitatorAccessToken\": \"A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg\", \"paymentSource\": \"paypal\" } }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/subscription-history-report") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "planId": "P-0C686669RW515132KMVBWDKQ", "data": { "orderID": "5KG37465D8302663E", "subscriptionID": "I-W59RR0145VJW", "facilitatorAccessToken": "A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg", "paymentSource": "paypal" } }); var requestOptions = { method: 'GET', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/subscription-history-report", 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://api.infinitemlmsoftware.com/subscription-history-report" method := "GET" payload := strings.NewReader(`{ "planId": "P-0C686669RW515132KMVBWDKQ", "data": { "orderID": "5KG37465D8302663E", "subscriptionID": "I-W59RR0145VJW", "facilitatorAccessToken": "A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg", "paymentSource": "paypal" } }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/subscription-history-report"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"planId\": \"P-0C686669RW515132KMVBWDKQ\", \"data\": { \"orderID\": \"5KG37465D8302663E\", \"subscriptionID\": \"I-W59RR0145VJW\", \"facilitatorAccessToken\": \"A21AAKiCRRiqYg9j7rzEByK_ChloDzehgN3G8jgnbGUaBVSMuV4YLq_QR9CW3RdZ7uI5n2tTO5wOjCwq222f2rhmpPxLXwGdg\", \"paymentSource\": \"paypal\" } }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

CRM

/crm-tiles

Header Parameters
api-keystring
access-tokenstring
GET/crm-tiles
curl --location 'https://api.infinitemlmsoftware.com/crm-tiles' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/crm-tiles") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/crm-tiles" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/crm-tiles', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/crm-tiles") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/crm-tiles", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-subscription-details" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/crm-tiles"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/crm-followup

Header Parameters
api-keystring
access-tokenstring
GET/crm-followup
curl --location 'https://api.infinitemlmsoftware.com/crm-followup' \ --header 'api-key: {{API_KEY}}' \ --header 'access-token: {{TOKEN}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/crm-followup") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["api-key"] = "{{API_KEY}}" request["access-token"] = "{{TOKEN}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/crm-followup" payload = {} headers = { 'api-key': '{{API_KEY}}', 'access-token': '{{TOKEN}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'api-key' => '{{API_KEY}}', 'access-token' => '{{TOKEN}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/crm-followup', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/crm-followup") .method("GET", body) .addHeader("api-key", "{{API_KEY}}") .addHeader("access-token", "{{TOKEN}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/crm-followup", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/crm-followup" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/crm-followup"); request.Headers.Add("api-key", "{{API_KEY}}"); request.Headers.Add("access-token", "{{TOKEN}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Replica

/get-replica-banner

Header Parameters
Acceptstring
api-keystring
access-tokenstring
GET/get-replica-banner
curl --location 'https://api.infinitemlmsoftware.com/get-replica-banner' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/get-replica-banner") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/get-replica-banner" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ?php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/get-replica-banner', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); RequestBody body = RequestBody.create(mediaType, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/get-replica-banner") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/get-replica-banner", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/get-replica-banner" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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.Get, "https://api.infinitemlmsoftware.com/get-replica-banner"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/replica-home

Header Parameters
api-keystring
access-tokenstring
Query Parameters
usernamestring
GET/replica-home
curl --location 'https://api.infinitemlmsoftware.com/replica-home?username=tester2' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/replica-home?username=tester2") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/replica-home?username=tester2" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/replica-home?username=tester2', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/replica-home?username=tester2") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/replica-home?username=tester2", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/replica-home?username=tester2" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/replica-home?username=tester2"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/replica-policy-terms

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
admin_user_namestring
GET/replica-policy-terms
curl --location 'https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: 387245a5a919ea2071cc406b10b89d4685e5cc8e' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "387245a5a919ea2071cc406b10b89d4685e5cc8e" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon" payload = {} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '387245a5a919ea2071cc406b10b89d4685e5cc8e', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '387245a5a919ea2071cc406b10b89d4685e5cc8e', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/replica-policy-terms?admin_user_name=binaryaddon"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "387245a5a919ea2071cc406b10b89d4685e5cc8e"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/replica-contact-upload

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
admin_user_namestring
Body Parameters
ownerIdnumber
contactDataobject
namestring
emailstring
addressstring
phonestring
contactInfostring
POST/replica-contact-upload
curl --location 'https://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json' \ --data '{ "ownerId": 3, "contactData": { "name": "dtykmjdtyk", "email": "atdtykdtuykdtykh", "address": "kdtysdtyks", "phone": "5647357", "contactInfo": "ke6t7yke" } }'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" request.body = JSON.dump({ "ownerId": 3, "contactData": { "name": "dtykmjdtyk", "email": "atdtykdtuykdtykh", "address": "kdtysdtyks", "phone": "5647357", "contactInfo": "ke6t7yke" } }) response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon" payload = json.dumps({ "ownerId": 3, "contactData": { "name": "dtykmjdtyk", "email": "atdtykdtuykdtykh", "address": "kdtysdtyks", "phone": "5647357", "contactInfo": "ke6t7yke" } }) headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("POST", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $body = '{ "ownerId": 3, "contactData": { "name": "dtykmjdtyk", "email": "atdtykdtuykdtykh", "address": "kdtysdtyks", "phone": "5647357", "contactInfo": "ke6t7yke" } }'; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon', $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, "{ \"ownerId\": 3, \"contactData\": { \"name\": \"dtykmjdtyk\", \"email\": \"atdtykdtuykdtykh\", \"address\": \"kdtysdtyks\", \"phone\": \"5647357\", \"contactInfo\": \"ke6t7yke\" } }"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var raw = JSON.stringify({ "ownerId": 3, "contactData": { "name": "dtykmjdtyk", "email": "atdtykdtuykdtykh", "address": "kdtysdtyks", "phone": "5647357", "contactInfo": "ke6t7yke" } }); var requestOptions = { method: 'POST', headers: myHeaders, body: raw, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon", 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://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon" method := "POST" payload := strings.NewReader(`{ "ownerId": 3, "contactData": { "name": "dtykmjdtyk", "email": "atdtykdtuykdtykh", "address": "kdtysdtyks", "phone": "5647357", "contactInfo": "ke6t7yke" } }`) client := &http.Client { } req, err := http.NewRequest(method, url, payload) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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://api.infinitemlmsoftware.com/replica-contact-upload?admin_user_name=binaryaddon"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent("{ \"ownerId\": 3, \"contactData\": { \"name\": \"dtykmjdtyk\", \"email\": \"atdtykdtuykdtykh\", \"address\": \"kdtysdtyks\", \"phone\": \"5647357\", \"contactInfo\": \"ke6t7yke\" } }", null, "application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/replica-payment-receipt-upload

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Query Parameters
admin_user_namestring
newUsernamestring
Body Parameters
filefile
admin_user_nametext
POST/replica-payment-receipt-upload
curl --location 'https://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}' \ --form 'admin_user_name="binaryaddon"'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" form_data = [['admin_user_name', 'binaryaddon']] request.set_form form_data, 'multipart/form-data' response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02" payload = {'admin_user_name': 'binaryaddon'} files=[ ] headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("POST", url, headers=headers, data=payload, files=files) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $options = [ 'multipart' => [ [ 'name' => 'admin_user_name', 'contents' => 'binaryaddon' ] ]]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02', $headers); $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("admin_user_name","binaryaddon") .build(); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var formdata = new FormData(); formdata.append("admin_user_name", "binaryaddon"); var requestOptions = { method: 'POST', headers: myHeaders, body: formdata, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02", 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://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02" method := "POST" payload := &bytes.Buffer{} writer := multipart.NewWriter(payload) _ = writer.WriteField("admin_user_name", "binaryaddon") 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.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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://api.infinitemlmsoftware.com/replica-payment-receipt-upload?admin_user_name=binaryaddon&newUsername=replica02"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new MultipartFormDataContent(); content.Add(new StringContent("binaryaddon"), "admin_user_name"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

/upload-replica-banner

Header Parameters
Acceptstring
api-keystring
access-tokenstring
Body Parameters
filefile
POST/upload-replica-banner
curl --location --request POST 'https://api.infinitemlmsoftware.com/upload-replica-banner' \ --header 'Accept: application/json' \ --header 'access-token: {{TOKEN}}' \ --header 'api-key: {{API_KEY}}'
require "uri" require "net/http" url = URI("https://api.infinitemlmsoftware.com/upload-replica-banner") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Post.new(url) request["Accept"] = "application/json" request["access-token"] = "{{TOKEN}}" request["api-key"] = "{{API_KEY}}" form_data = [] request.set_form form_data, 'multipart/form-data' response = https.request(request) puts response.read_body
import requests url = "https://api.infinitemlmsoftware.com/upload-replica-banner" payload = {} files={} headers = { 'Accept': 'application/json', 'access-token': '{{TOKEN}}', 'api-key': '{{API_KEY}}' } response = requests.request("POST", url, headers=headers, data=payload, files=files) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'access-token' => '{{TOKEN}}', 'api-key' => '{{API_KEY}}' ]; $request = new Request('POST', 'https://api.infinitemlmsoftware.com/upload-replica-banner', $headers); $res = $client->sendAsync($request)->wait(); echo $res->getBody();
OkHttpClient client = new OkHttpClient().newBuilder() .build(); MediaType mediaType = MediaType.parse("text/plain"); MediaType JSON = MediaType.parse("application/json; charset=utf-8"); RequestBody body = RequestBody.create(JSON, "{}"); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/upload-replica-banner") .method("POST", body) .addHeader("Accept", "application/json") .addHeader("access-token", "{{TOKEN}}") .addHeader("api-key", "{{API_KEY}}") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("access-token", "{{TOKEN}}"); myHeaders.append("api-key", "{{API_KEY}}"); var formdata = new FormData(); var requestOptions = { method: 'POST', headers: myHeaders, body: formdata, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/upload-replica-banner", 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://api.infinitemlmsoftware.com/upload-replica-banner" method := "POST" payload := &bytes.Buffer{} writer := multipart.NewWriter(payload) 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.Add("Accept", "application/json") req.Header.Add("access-token", "{{TOKEN}}") req.Header.Add("api-key", "{{API_KEY}}") 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://api.infinitemlmsoftware.com/upload-replica-banner"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("access-token", "{{TOKEN}}"); request.Headers.Add("api-key", "{{API_KEY}}"); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());

Check Email and Username

Header Parameters
Acceptstring
api-keystring
Query Parameters
fieldstring
fieldstring
GET/upload-replica-banner
curl --location 'https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993' \ --header 'Accept: application/json' \ --header 'api-key: {{API_KEY}}' \ --header 'Content-Type: application/json'
require "uri" require "json" require "net/http" url = URI("https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993") https = Net::HTTP.new(url.host, url.port) https.use_ssl = true request = Net::HTTP::Get.new(url) request["Accept"] = "application/json" request["api-key"] = "{{API_KEY}}" request["Content-Type"] = "application/json" response = https.request(request) puts response.read_body
import requests import json url = "https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993" payload = {} headers = { 'Accept': 'application/json', 'api-key': '{{API_KEY}}', 'Content-Type': 'application/json' } response = requests.request("GET", url, headers=headers, data=payload) print(response.text)
< ? php $client = new Client(); $headers = [ 'Accept' => 'application/json', 'api-key' => '{{API_KEY}}', 'Content-Type' => 'application/json' ]; $request = new Request('GET', 'https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993', $headers); $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, ""); Request request = new Request.Builder() .url("https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993") .method("GET", body) .addHeader("Accept", "application/json") .addHeader("api-key", "{{API_KEY}}") .addHeader("Content-Type", "application/json") .build(); Response response = client.newCall(request).execute();
var myHeaders = new Headers(); myHeaders.append("Accept", "application/json"); myHeaders.append("api-key", "{{API_KEY}}"); myHeaders.append("Content-Type", "application/json"); var requestOptions = { method: 'GET', headers: myHeaders, redirect: 'follow' }; fetch("https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993", requestOptions) .then(response => response.text()) .then(result => console.log(result)) .catch(error => console.log('error', error));
package main import ( "fmt" "net/http" "io/ioutil" ) func main() { url := "https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993" method := "GET" client := &http.Client { } req, err := http.NewRequest(method, url, nil) if err != nil { fmt.Println(err) return } req.Header.Add("Accept", "application/json") req.Header.Add("api-key", "{{API_KEY}}") req.Header.Add("Content-Type", "application/json") 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.Get, "https://api.infinitemlmsoftware.com/replica-checkUsernameEmail?field=username&value=inf67512993"); request.Headers.Add("Accept", "application/json"); request.Headers.Add("api-key", "{{API_KEY}}"); var content = new StringContent(string.Empty); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); request.Content = content; var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync());
×
Infinite MLM Software
Version 12.0 has been released !!!
With Highly Augmented Features
Try demo to experience features of MLM Software 12.0
A quick glimpse at released version 12.0 features
Whatsapp