Point of Sale
Overview
POSaBIt Point-of-Sale API endpoints. Allows for the ability to read and update inventory, manifests, coupons, customers and transaction data.
The first step to obtaining API access with POSaBIT is executing an API Agreement. This agreement is required for both retailers and third-party partners before any credentials are issued or endpoints can be accessed. The API Agreement ensures compliance with POSaBIT policies and defines the rights and responsibilities of all parties when using our APIs. Completing this step establishes a secure foundation for integration and ongoing data exchange. Please reach out to POSaBIT at support@posabit.com for inquiries regarding API access.
POSaBIT is in the process of migrating all partners to our v3 API endpoints. Earlier versions (v1 and) will be deprecated and fully sunset in the near future. The official sunset date is still to be determined and will be announced several months in advance to allow partners sufficient time to complete their migration. We strongly recommend beginning development against v3 endpoints as soon as possible to ensure a smooth transition.
Base URL:
| Staging Env | Production Env |
|---|---|
| https://staging-app.posabit.com/api | https://app.posabit.com/api |
Requirements
- Active POSaBIT merchant account
- Active POSaBIT integrator API Token
- Active POSaBIT venue API Token
Authentication
POSaBIT's API v3 requires 2 pieces of information to authenticate each request, the integrator API token and the venue API token.
Both authenticating API tokens must be sent through the Authorization HTTP header using the basic access authentication method. Basic access authentication combines a username and password, encodes them using Base64, and the resulting value is then passed through via the Authorization HTTP header. For our API, the username is equivalent to the software integrator's API token and the password is equivalent to the venue API token. The Authorization HTTP header for this API is prepared as follows:
Both API tokens are combined into a single string in the following manner: integrator_api_token:venue_api_token The combined string is then encoded using RFC2045-MIME Base64 without the 76 char/line limit. The HTTP header value is composed of the literal word Basic followed by a space and the encoded string: Basic encoded_api_tokens
If you have received only an integrator API token, you can use that to make a GET request to /v3/info with the above basic access authentication method with the venue_api_token part being blank. That will return a list of all available venues for your integrator with the current status of the integration and the venue token to use for each.
POSaBIT API Menu
Providing access to a menu partner with POSaBIT requires a few simple steps for the store. Create a menu feed (or re-use an existing feed) the partner will use, if the partner is pulling menu information from POSaBIT. Create an API token for the partner. Share the information with the partner.
The partner will use the information to pull the store’s menu feed and can also use the api_token to push orders to the store, if they have integrated orders with POSaBIT.
Step 1 - Create a menu feed
Follow the directions in Creating a POSaBIT Menu, steps 1-6.
Step 2 - Create an API token
Follow the directions in Creating a POSaBIT Menu, steps 8-9.
Step 3 - Share the information with the partner
Provide the partner the information from the above two steps. They will need: * API Token (e.g. 35uQ1SJ23YdvnBF_pLGUrt ) * Menu feed key (e.g. 6854d0e3-bd04-47ae-9cbc-dbf21060fd38)
How the partner uses this information
The partner will use this information to call the posabit api to get the menu feed as well as to push orders into the POS.
Menu Feed
The POSaBIT menu feed api is just a single call to get menu information as JSON.
The structure of the menu feed is:
menu feed meta data
array of categories
category data
array of products
product data
array of prices (variations of the product)
price data
An example menu feed can be retrieved from our sandbox using:
https://staging-app.posabit.com/api/v3/menu_feeds/
To use the url, you will need the following API Token: 6gnUJZXgtQdXDZn97JkPyQ
The API Token should be passed in the authorization header as a Bearer token (e.g. Bearer 6gnUJZXgtQdXDZn97JkPyQ in the authorization header).
For production, the url would be:
https://app.posabit.com/api/v3/menu_feeds/
The api token would be passed in the authorization header as a bearer token, as above.
Incoming Orders
A 3rd party menu partner can send orders into our POS system using our incoming_order end point. At a high level, it just receives an order header, and the items for the order, including the POSaBIT product_id that is part of the menu feed.
Incoming order staging endpoint: https://staging-app.posabit.com/api/v3/incoming_orders
The incoming_order can use the same api token as above as a Bearer token. See the example payload for an incoming order below.
Swagger Docs for our external api calls: https://app.posabit.com/api-docs/index.html
Menu Feed Description
{
"menu_feed": {
"title": "Menu feed title",
"feed_key": "Menu feed key",
"description": "Menu feed description",
"feed_type": "endpoint",
"menu_groups": [
{
"name": "Group 1 (e.g. Flower)",
"category_guid": "Unique id for category",
"name_template": "internal use for product names",
"combine_weights": "true/false: True: different products of the same brand and strain are combined into 1 product with price variations",
"description": "Category description",
"image": {
"is_default": "true/false: True, this is a default image.",
"og": "URL of original category image.",
"lg": "URL of large category image.",
"md": "URL of medium category image.",
"sm": "URL of small category image."
},
"menu_items": [
{
"id": "Unique ID of product",
"guid": "GUID for product",
"name": "Name of product",
"description": "",
"flower_type": "Flower type",
"brand": "Brand",
"strain": "Strain",
"product_type": "Product Type",
"brand_logo": {
"is_default": "true/false: True, this is a default image. (not specific to brand)",
"og": "URL of original brand image.",
"lg": "URL of large brand image.",
"md": "URL of medium brand image.",
"sm": "URL of small brand image."
},
"product_image": {
"is_default": "true/false: True, this is a default image. (not specific to product)",
"og": "URL of original product image.",
"lg": "URL of large product image.",
"md": "URL of medium product image.",
"sm": "URL of small product image.",
"thumb": "URL of thumbnail product image"
},
"prices": [
{
"id": "product id. It should be used to submit orders",
"name": "product name",
"price_cents": 1100,
"unit": "weight of product (e.g. 3.5)",
"unit_type": "gm",
"quantity_on_hand": "qty on hand"
},
{
"id": "product id 2. Same product just different weight",
"name": "product name",
"price_cents": 1100,
"unit": "weight of product (e.g. 7.0)",
"unit_type": "gm",
"quantity_on_hand": "qty on hand"
}
],
"thc": {
"low": "low thc",
"high": "high thc",
"unit_type": "thc unit (% or mg)"
},
"cbd": {
"low": "low cbd",
"high": "high cbd",
"unit_type": "cbd unit (% or mg)"
}
}
]
}
]
}
}
Incoming Order Example Payload
{
"incoming_order": {
"order_type": "delivery",
"first_name": "Suzie3",
"last_name": "Q",
"email": "Suzie@example.com",
"telephone": "2558806107",
"address": "123 Main St",
"city": "Seattle",
"state_abbrev": "WA",
"zipcode": "98033",
"reference_no": "12349",
"source": "kiosk",
"requested_payment_method": "ACH",
"requested_date": "2021-01-12",
"requested_window_start_time": "11am",
"requested_window_end_time": "12am",
"notes": "Knock 4 times then 20 times",
"order_items_attributes": [{
"product_parent_id": "Blazin' - Treehawk Farms - Flower",
"product_id": 900835,
"product_name": "Blazin' - 9lb Hammer (3.5g)",
"product_brand": "Blazin'",
"product_strain": "9lb Hammer",
"weight": "3.5gm",
"price": 4000,
"quantity": 2
}, {
"product_parent_id": "Granddaddy Purple - Solstice - Pre-Roll",
"product_id": 900936,
"product_name": "Solstice - Granddaddy Purple Pre-Roll (1.5g)",
"product_brand": "Solstice",
"product_strain": "Granddaddy Purple",
"weight": "1.5gm",
"price": 2000,
"quantity": 1
}]
}
}
Incoming Order Status Callbacks
When a 3rd party menu partner sends an order through Posabit, they may want to determine if that order has been completed. There are two different ways of doing this: The first way is to ask Posabit for the status of a particular order with the REST API, using its unique identifier (ID). The second way is to provide a Status Callback URL when you send the message through the API.
Here is a code sample that shows how to set a webhook URL for status callbacks on incoming orders:
{
"incoming_order": {
"order_type": "delivery",
"first_name": "Suzie3",
"last_name": "Q",
"email": "Suzie@example.com",
"telephone": "2558806107",
"address": "123 Main St",
"city": "Seattle",
"state_abbrev": "WA",
"status_callback": "https://third.party.com/posabit/orders",
"zipcode": "98033",
"reference_no": "12349",
"source": "kiosk",
"requested_payment_method": "ACH",
"requested_date": "2021-01-12",
"requested_window_start_time": "11am",
"requested_window_end_time": "12am",
"notes": "Knock 4 times then 20 times",
"order_items_attributes": [{
"product_parent_id": "Blazin' - Treehawk Farms - Flower",
"product_id": 900835,
"product_name": "Blazin' - 9lb Hammer (3.5g)",
"product_brand": "Blazin'",
"product_strain": "9lb Hammer",
"weight": "3.5gm",
"price": 4000,
"quantity": 2
}, {
"product_parent_id": "Granddaddy Purple - Solstice - Pre-Roll",
"product_id": 900936,
"product_name": "Solstice - Granddaddy Purple Pre-Roll (1.5g)",
"product_brand": "Solstice",
"product_strain": "Granddaddy Purple",
"weight": "1.5gm",
"price": 2000,
"quantity": 1
}]
}
}
Posabit will send an update to that URL every time the status changes; you'll find the status information in the status value. Order Status values include:
- Pending: Awaiting Fulfillment
- Change: The Order has been modified and is waiting for Fulfillment.
- Processing: Processing or Paused by Fulfillment.
- Completed: Completed by Fulfillment and awaiting Delivery.
- En Route: Out for Delivery
- STS Failed: Failed to create STS Delivery
- Delivered: Delivery Completed
- Canceled: Canceled
Your status delivery URL will receive an HTTP POST request with the application/x-www-form-urlencoded content type.
The body of the status delivery message will look similar to the following: ```json { "incoming_order": { "id": 12345, "reference_no": "your_internal_order_id", "status": "pending", "order_type": "pickup" } }
POSaBIT APIs v3
Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.
Point of Sale API
GET info
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/info',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/info', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/info", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/info";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/info \
-H 'Accept: application/json'
GET /v3/info
Example responses
200 Response
{
"code": 1,
"venues": [
{
"venue_name": "The Pot Shop",
"active": true,
"venue_token": "abcdefg12345ABCDEFG123",
"first_connected_date": "2025-09-26",
"last_connected_date": "2025-09-29"
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
POST incoming_orders
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json'
}
result = RestClient.post '/v3/incoming_orders',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
r = requests.post('/v3/incoming_orders', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/v3/incoming_orders", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePostRequest()
{
string url = "/v3/incoming_orders";
await PostAsync(null, url);
}
/// Performs a POST Request
public async Task PostAsync(undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute POST request
HttpResponseMessage response = await Client.PostAsync(url, jsonContent);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X POST /v3/incoming_orders \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
POST /v3/incoming_orders
Body parameter
{
"incoming_order": {
"order_type": "pickup",
"first_name": "John",
"last_name": "Doe",
"email": "test@posabit.com",
"telephone": "5551112222",
"address": "",
"city": "",
"state_abbrev": "",
"zipcode": "",
"reference_no": "12345-86-123",
"notes": "Gets free lighter",
"requested_payment_method": "cash",
"source": "online_store",
"order_items_attributes": [
{
"product_parent_id": "Treehawk Farms - Wifi OG Pre-Roll 2pk (1g)",
"product_id": 808542,
"quantity": 2
}
]
}
}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| venue_token | path | string | true | none |
| body | body | object | false | none |
Example responses
200 Response
{
"code": 1,
"incoming_order": {
"id": 19800,
"aasm_state": "pending",
"reference_no": "12345-86-123",
"first_name": "John",
"last_name": "Doe",
"source": "online_store",
"order_type": "pickup",
"notes": "Gets free lighter",
"delivered_at": null,
"requested_date": null,
"requested_window_start_time": {},
"requested_window_end_time": {},
"requested_payment_method": "cash",
"payment_verified": false,
"curbside": false,
"created_at": "2024-10-03T19:12:19.000Z",
"updated_at": "2024-10-03T19:12:19.000Z"
},
"order_items": [
{
"item_id": 32744,
"product_id": 808542,
"sku_id": 115866,
"manifest_item_id": null,
"product_name": "Treehawk Farms - Wifi OG Pre-Roll 2pk (1g)",
"product_brand": "Treehawk Farms",
"product_strain": "Wifi OG",
"weight": null,
"quantity": 2,
"unit_quantity": "2.0",
"price": 1000,
"discount": null,
"tax": null,
"tier_weight_id": null,
"coupons": [],
"taxes": [],
"created_at": "2024-10-03T19:12:19.000Z",
"updated_at": "2024-10-03T19:12:19.000Z"
}
]
}
422 Response
{
"errors": [
"Reference no has already been taken"
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 422 | Unprocessable Entity | Unprocessable Content | Inline |
Response Schema
GET {token} incoming_orders
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/incoming_orders/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/incoming_orders/{id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/incoming_orders/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/incoming_orders/{id}";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/incoming_orders/{id} \
-H 'Accept: application/json'
GET /v3/incoming_orders/{id}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| venue_token | path | string | true | none |
| id | path | string | true | none |
Example responses
200 Response
{
"code": 1,
"incoming_order": {
"id": 19798,
"aasm_state": "processing",
"reference_no": "3221-1727814981-bb1314bf",
"first_name": "A",
"last_name": "A",
"source": "posabit_v2",
"order_type": "pickup",
"notes": null,
"delivered_at": null,
"requested_date": null,
"requested_window_start_time": {},
"requested_window_end_time": {},
"requested_payment_method": "cash",
"payment_verified": false,
"curbside": false,
"created_at": "2024-10-01T20:39:23.000Z",
"updated_at": "2024-10-01T20:41:19.000Z"
},
"order_items": [
{
"item_id": 32713,
"product_id": 800583,
"sku_id": 107907,
"manifest_item_id": null,
"product_name": "'oh' McDonald Farms - Nuken (1g)",
"product_brand": "'oh' McDonald Farms",
"product_strain": "Nuken",
"weight": "1.1g",
"quantity": 1,
"unit_quantity": "1.1",
"price": 1500,
"discount": 0,
"tax": 473,
"tier_weight_id": null,
"coupons": [],
"taxes": [],
"created_at": "2024-10-01T20:36:21.000Z",
"updated_at": "2024-10-01T20:36:21.000Z"
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
POST {token} incoming_quotes
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json'
}
result = RestClient.post '/v3/incoming_quotes',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
r = requests.post('/v3/incoming_quotes', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/v3/incoming_quotes", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePostRequest()
{
string url = "/v3/incoming_quotes";
await PostAsync(null, url);
}
/// Performs a POST Request
public async Task PostAsync(undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute POST request
HttpResponseMessage response = await Client.PostAsync(url, jsonContent);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X POST /v3/incoming_quotes \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
POST /v3/incoming_quotes
Body parameter
{
"quote": {
"incoming_order_id": null,
"venue_id": 3221,
"fulfillment": {
"source": "posabit_v2",
"order_type": "pickup",
"requested_date": null,
"requested_window_start_time": null,
"requested_window_end_time": null,
"tip_amount": 0,
"tip_type": null,
"processing_fee": 300,
"tip_calculated": 0,
"delivery_address": {
"address": "",
"city": "",
"state_abbrev": "",
"zipcode": ""
}
},
"customer": {
"first_name": "Jane",
"last_name": "Doe",
"email": "test@posabit.com",
"telephone": "5551112222",
"customer_type": "recreational"
},
"payment": {
"requested_payment_method": "cash"
},
"items": [
{
"sku_id": 107907,
"quantity": 1,
"product_id": 800583,
"name": "'oh' McDonald Farms - Nuken (1g)",
"unit_type": "g",
"unit": "1.1",
"variant_id": "k107907",
"quantity_on_hand": 30,
"test_results": {
"thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"cbd": {
"current": 10,
"low": 10,
"high": 10,
"unit_type": "%"
},
"thca": null,
"cbda": null,
"total_thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"total_cbd": null,
"thcv": null,
"cbdv": null,
"cbc": null,
"cbca": null,
"cbcv": null,
"cbn": null,
"cbg": null,
"cbga": null,
"cbgv": null
},
"terpene_results": [],
"product_image": {
"is_product_specific_image": true,
"lg": "https://pbit-staging.s3.amazonaws.com/images/image/210/large_image.jpg",
"md": "https://pbit-staging.s3.amazonaws.com/images/image/210/medium_image.jpg"
},
"discount": 0,
"price": 1500,
"discount_ids": []
}
]
}
}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| venue_token | path | string | true | none |
| body | body | object | false | none |
Example responses
200 Response
{
"code": 1,
"quote": {
"reference_no": "3221-1727982977-3f59c5f1",
"incoming_order_id": null,
"venue_id": 3221,
"fulfillment": {
"source": "posabit_v2",
"order_type": "pickup",
"requested_date": null,
"requested_window_start_time": null,
"requested_window_end_time": null,
"tip_amount": 0,
"tip_type": null,
"processing_fee": 300,
"tip_calculated": 0,
"delivery_address": {
"address": "",
"city": "",
"state_abbrev": "",
"zipcode": ""
}
},
"customer": {
"first_name": "Jane",
"last_name": "Doe",
"email": "test@posabit.com",
"telephone": "5551112222",
"customer_type": "recreational"
},
"payment": {
"requested_payment_method": "cash"
},
"items": [
{
"sku_id": 107907,
"quantity": 1,
"product_id": 800583,
"name": "'oh' McDonald Farms - Nuken (1g)",
"unit_type": "g",
"unit": "1.1",
"variant_id": "k107907",
"quantity_on_hand": 30,
"test_results": {
"thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"cbd": {
"current": 10,
"low": 10,
"high": 10,
"unit_type": "%"
},
"thca": null,
"cbda": null,
"total_thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"total_cbd": null,
"thcv": null,
"cbdv": null,
"cbc": null,
"cbca": null,
"cbcv": null,
"cbn": null,
"cbg": null,
"cbga": null,
"cbgv": null
},
"terpene_results": [],
"product_image": {
"is_product_specific_image": true,
"lg": "https://pbit-staging.s3.amazonaws.com/images/image/210/large_image.jpg",
"md": "https://pbit-staging.s3.amazonaws.com/images/image/210/medium_image.jpg"
},
"discount": 0,
"price": 1500,
"discount_ids": []
}
],
"taxes": [
{
"tax_id": 4286,
"name": "Bellingham, WA",
"price_included": true,
"amount": 93,
"tax_rate": "9.0"
},
{
"tax_id": 4285,
"name": "Cannabis Tax",
"price_included": true,
"amount": 380,
"tax_rate": "37.0"
}
],
"totals": {
"discount_ids": [],
"subtotal": 1500,
"discount": 0,
"tax": 473,
"total": 1500
},
"limits": {
"exceeded_limits": [],
"sum_per_limit": {
"recreational_flower": 1.1
}
}
}
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
PUT {token} incoming_quotes
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json'
}
result = RestClient.put '/v3/incoming_quotes/{reference_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
r = requests.put('/v3/incoming_quotes/{reference_id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/v3/incoming_quotes/{reference_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePutRequest()
{
int id = 1;
string url = "/v3/incoming_quotes/{reference_id}";
var result = await PutAsync(id, null, url);
}
/// Performs a PUT Request
public async Task PutAsync(int id, undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute PUT request
HttpResponseMessage response = await Client.PutAsync(url + $"/{id}", jsonContent);
//Return response
return await DeserializeObject(response);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X PUT /v3/incoming_quotes/{reference_id} \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
PUT /v3/incoming_quotes/{reference_id}
Body parameter
{
"quote": {
"fulfillment": {
"source": "posabit_v2",
"order_type": "online",
"requested_date": "2024-10-03",
"requested_window_start_time": null,
"requested_window_end_time": null,
"tip_amount": "10",
"tip_type": 1,
"processing_fee": 1.5,
"delivery_address": {
"address": "321 Test Lane",
"city": "Seattle",
"state_abbrev": "WA",
"zipcode": "12345"
}
},
"incoming_order_id": "3221-102-19299993",
"customer": {
"first_name": "John",
"last_name": "Doe",
"email": "test@posabit.com",
"telephone": "555-111-2222",
"customer_type": "recreational"
},
"payment": {
"requested_payment_method": "ach"
}
}
}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| venue_token | path | string | true | none |
| reference_id | path | string | true | none |
| body | body | object | false | none |
Example responses
200 Response
{
"code": 1,
"quote": {
"reference_no": "3221-1727982977-3f59c5f1",
"incoming_order_id": null,
"venue_id": 3221,
"fulfillment": {
"source": "posabit_v2",
"order_type": "online",
"requested_date": "2024-10-03",
"requested_window_start_time": null,
"requested_window_end_time": null,
"tip_amount": 10,
"tip_type": "1",
"processing_fee": 1,
"tip_calculated": 1000,
"delivery_address": {
"address": "321 Test Lane",
"city": "Seattle",
"state_abbrev": "WA",
"zipcode": "12345"
}
},
"customer": {
"first_name": "John",
"last_name": "Doe",
"email": "test@posabit.com",
"telephone": "5551112222",
"customer_type": "recreational"
},
"payment": {
"requested_payment_method": "ach"
},
"items": [
{
"sku_id": 107907,
"quantity": 1,
"product_id": 800583,
"name": "'oh' McDonald Farms - Nuken (1g)",
"unit_type": "g",
"unit": "1.1",
"variant_id": "k107907",
"quantity_on_hand": 30,
"test_results": {
"thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"cbd": {
"current": 10,
"low": 10,
"high": 10,
"unit_type": "%"
},
"thca": null,
"cbda": null,
"total_thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"total_cbd": null,
"thcv": null,
"cbdv": null,
"cbc": null,
"cbca": null,
"cbcv": null,
"cbn": null,
"cbg": null,
"cbga": null,
"cbgv": null
},
"terpene_results": [],
"product_image": {
"is_product_specific_image": true,
"lg": "https://pbit-staging.s3.amazonaws.com/images/image/210/large_image.jpg",
"md": "https://pbit-staging.s3.amazonaws.com/images/image/210/medium_image.jpg"
},
"discount": 0,
"price": 1500,
"discount_ids": []
}
],
"taxes": [],
"totals": {
"discount_ids": [],
"subtotal": 1500,
"discount": 0,
"tax": 473,
"total": 1500
},
"limits": {
"exceeded_limits": [],
"sum_per_limit": {
"recreational_flower": 1.1
}
}
}
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
GET incoming_quotes/{id}
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/incoming_quotes/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/incoming_quotes/{id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/incoming_quotes/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/incoming_quotes/{id}";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/incoming_quotes/{id} \
-H 'Accept: application/json'
GET /v3/incoming_quotes/{id}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| reference_id | path | string | true | none |
Example responses
200 Response
{
"code": 1,
"quote": {
"reference_no": "3221-1727814981-bb1314bf",
"incoming_order_id": null,
"venue_id": 3221,
"fulfillment": {
"source": "posabit_v2",
"order_type": "pickup",
"requested_date": null,
"requested_window_start_time": null,
"requested_window_end_time": null,
"tip_amount": 0,
"tip_type": null,
"processing_fee": 300,
"tip_calculated": 0,
"delivery_address": {
"address": "",
"city": "",
"state_abbrev": "",
"zipcode": ""
}
},
"customer": {
"first_name": "Jane",
"last_name": "Doe",
"email": "test@posabit.com",
"telephone": "5551111111",
"customer_type": "recreational"
},
"payment": {
"requested_payment_method": "cash"
},
"items": [
{
"sku_id": 107907,
"quantity": 1,
"product_id": 800583,
"name": "'oh' McDonald Farms - Nuken (1g)",
"unit_type": "g",
"unit": "1.1",
"variant_id": "k107907",
"quantity_on_hand": 30,
"test_results": {
"thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"cbd": {
"current": 10,
"low": 10,
"high": 10,
"unit_type": "%"
},
"thca": null,
"cbda": null,
"total_thc": {
"current": 4.2,
"low": 4.2,
"high": 4.2,
"unit_type": "%"
},
"total_cbd": null,
"thcv": null,
"cbdv": null,
"cbc": null,
"cbca": null,
"cbcv": null,
"cbn": null,
"cbg": null,
"cbga": null,
"cbgv": null
},
"terpene_results": [],
"product_image": {
"is_product_specific_image": true,
"lg": "https://pbit-staging.s3.amazonaws.com/images/image/210/large_image.jpg",
"md": "https://pbit-staging.s3.amazonaws.com/images/image/210/medium_image.jpg"
},
"discount": 0,
"price": 1500,
"discount_ids": []
}
],
"taxes": [],
"totals": {
"discount_ids": [],
"subtotal": 1500,
"discount": 0,
"tax": 473,
"total": 1500
},
"limits": {
"exceeded_limits": [],
"sum_per_limit": {
"recreational_flower": 1.1
}
}
}
}
404 Response
{
"error": "Quote not found"
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 404 | Not Found | Not Found | Inline |
Response Schema
GET menu_feeds
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/menu_feeds/{menu_feed_key}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/menu_feeds/{menu_feed_key}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/menu_feeds/{menu_feed_key}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/menu_feeds/{menu_feed_key}";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/menu_feeds/{menu_feed_key} \
-H 'Accept: application/json; charset=utf-8'
GET /v3/menu_feeds/{menu_feed_key}
Returns the menu feed integration response
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| venue_token | path | string | true | Venue API Token |
| menu_feed_key | path | string | true | Menu Feed Key |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
| 404 | Not Found | Not Found | None |
Response Schema
GET info
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/info',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/info', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/info", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/info";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/info \
-H 'Accept: application/json'
GET /v3/venue/info
Example responses
200 Response
{
"name": "The Bong Marché",
"license": "413813",
"region": "Washington State",
"locale": "en-US",
"vertical": "dispensaries",
"logo_thumb": "https://pbit-staging.s3.amazonaws.com/logos/Venue/thumb_3221_logo.png",
"logo_medium": "https://pbit-staging.s3.amazonaws.com/logos/Venue/medium_3221_logo.png",
"telephone": "",
"address": "1128 8th St, Kirkland, WA",
"street_address_line_1": "1128 8th St",
"city": "Kirkland",
"state": "WA",
"zip_code": "98000",
"country": "USA",
"timezone": "Pacific Time (US & Canada)",
"latitude": "48.7382",
"longitude": "-122.47",
"domains": [],
"tax_rates": [
{
"id": 4285,
"name": "Cannabis Tax",
"rate": 3700,
"tax_rate": "37.0",
"price_included": true
},
{
"id": 4286,
"name": "Bellingham, WA",
"rate": 900,
"tax_rate": "9.0",
"price_included": true
}
],
"payment_methods": [
"Cash",
"Debit Card",
"Other"
],
"venue_settings": {
"online_order_curbside": "1",
"online_order_delivery": "1"
}
}
401 Response
{
"message": "Invalid Token"
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 401 | Unauthorized | Unauthorized | Inline |
Response Schema
GET customers
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/customers',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/customers', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/customers", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/customers";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/customers \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/customers
Returns a list of customers
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[id_number_cont] | query | string | false | Filter where customer ID number contains provided value |
| q[telephone_eq] | query | string | false | Filter where telephone equals provided value |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 400 | Bad Request | Bad Request | None |
| 401 | Unauthorized | Unauthorized | None |
| 422 | Unprocessable Entity | Invalid Parameters | None |
| 500 | Internal Server Error | Internal Server Error | None |
Response Schema
POST customers
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.post '/v3/venue/customers',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json; charset=utf-8'
}
r = requests.post('/v3/venue/customers', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "/v3/venue/customers", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePostRequest()
{
string url = "/v3/venue/customers";
await PostAsync(null, url);
}
/// Performs a POST Request
public async Task PostAsync(undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute POST request
HttpResponseMessage response = await Client.PostAsync(url, jsonContent);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X POST /v3/venue/customers \
-H 'Content-Type: application/json' \
-H 'Accept: application/json; charset=utf-8'
POST /v3/venue/customers
Create a new customer
Body parameter
false
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 204 | No Content | Record not found | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET customers/{id}
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/customers/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/customers/{id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/customers/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/customers/{id}";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/customers/{id} \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/customers/{id}
Returns a customer by id
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| id | path | integer(int32) | true | Customer ID |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 400 | Bad Request | Bad Request | None |
| 401 | Unauthorized | Unauthorized | None |
| 422 | Unprocessable Entity | Invalid parameters | None |
| 500 | Internal Server Error | Internal Server Error | None |
Response Schema
PUT customers/{id}
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.put '/v3/venue/customers/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json; charset=utf-8'
}
r = requests.put('/v3/venue/customers/{id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/v3/venue/customers/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePutRequest()
{
int id = 1;
string url = "/v3/venue/customers/{id}";
var result = await PutAsync(id, null, url);
}
/// Performs a PUT Request
public async Task PutAsync(int id, undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute PUT request
HttpResponseMessage response = await Client.PutAsync(url + $"/{id}", jsonContent);
//Return response
return await DeserializeObject(response);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X PUT /v3/venue/customers/{id} \
-H 'Content-Type: application/json' \
-H 'Accept: application/json; charset=utf-8'
PUT /v3/venue/customers/{id}
Update an existing customer
Body parameter
false
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| id | path | integer(int32) | true | Customer ID |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 204 | No Content | Record not found | None |
| 400 | Bad Request | Bad Request | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET customer_tags
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/customer_tags',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/customer_tags', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/customer_tags", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/customer_tags";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/customer_tags \
-H 'Accept: application/json'
GET /v3/venue/customer_tags
Update an existing customer
Example responses
200 Response
{
"total_records": 13,
"current_page": 1,
"total_pages": 1,
"per_page": 1000,
"customer_tags": [
{
"id": 1,
"merchant_id": 7684,
"name": "veteran",
"active": true,
"pos_enabled": true,
"description": "",
"discount_limit": null,
"taggings_count": 2226,
"color": "#AE2014",
"created_at": "2019-05-30T22:49:21.000Z",
"updated_at": "2019-10-07T19:47:10.000Z"
},
{
"id": 2,
"merchant_id": 7684,
"name": "Industry",
"active": true,
"pos_enabled": true,
"description": "",
"discount_limit": null,
"taggings_count": 275,
"color": "#5B77D0",
"created_at": "2019-06-03T16:58:55.000Z",
"updated_at": "2019-10-07T19:47:17.000Z"
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
PUT /customer_tags/add
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json'
}
result = RestClient.put '/v3/venue/customers/{id}/customer_tags/add',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
r = requests.put('/v3/venue/customers/{id}/customer_tags/add', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/v3/venue/customers/{id}/customer_tags/add", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePutRequest()
{
int id = 1;
string url = "/v3/venue/customers/{id}/customer_tags/add";
var result = await PutAsync(id, null, url);
}
/// Performs a PUT Request
public async Task PutAsync(int id, undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute PUT request
HttpResponseMessage response = await Client.PutAsync(url + $"/{id}", jsonContent);
//Return response
return await DeserializeObject(response);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X PUT /v3/venue/customers/{id}/customer_tags/add \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
PUT /v3/venue/customers/{id}/customer_tags/add
Body parameter
{
"tag_ids": [
3
]
}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| body | body | object | false | none |
Example responses
200 Response
{
"customer": {
"id": 1448750,
"first_name": "JANE",
"terms_agreed": false,
"points": 0,
"loyalty": true,
"loyalty_number": "1448750",
"last_name": "",
"birth_year": null,
"gender": "female",
"telephone": "5552655555",
"email": "",
"active": true,
"sms_opt_out": true,
"sms_opt_in": false,
"address": "",
"zipcode": "98119",
"city": "SEATTLE",
"state": "WA",
"birthday": null,
"customer_type": "medical",
"id_expiration": "2032-01-01",
"medical_card_expiration": "2026-01-01",
"drivers_license": "WDLB",
"customer_tags": [
{
"id": 296,
"merchant_id": 7684,
"name": "Industry",
"active": true,
"pos_enabled": true,
"manager_approval": true,
"description": "",
"discount_limit": null,
"taggings_count": 2,
"color": "#d82206",
"created_at": "2023-12-12T20:07:52.000Z",
"updated_at": "2023-12-12T20:08:09.000Z"
},
{
"id": 3,
"merchant_id": 7684,
"name": "Local Business",
"active": true,
"pos_enabled": true,
"manager_approval": false,
"description": "",
"discount_limit": null,
"taggings_count": 5924,
"color": "#AB1E1C",
"created_at": "2019-06-04T15:17:53.000Z",
"updated_at": "2021-07-19T16:46:47.000Z"
}
]
}
}
404 Response
{
"code": 204,
"message": "Cannot find customer"
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 404 | Not Found | Not Found | Inline |
Response Schema
PUT /customer_tags/remove
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json'
}
result = RestClient.put '/v3/venue/customers/{id}/customer_tags/remove',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
r = requests.put('/v3/venue/customers/{id}/customer_tags/remove', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/v3/venue/customers/{id}/customer_tags/remove", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePutRequest()
{
int id = 1;
string url = "/v3/venue/customers/{id}/customer_tags/remove";
var result = await PutAsync(id, null, url);
}
/// Performs a PUT Request
public async Task PutAsync(int id, undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute PUT request
HttpResponseMessage response = await Client.PutAsync(url + $"/{id}", jsonContent);
//Return response
return await DeserializeObject(response);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X PUT /v3/venue/customers/{id}/customer_tags/remove \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
PUT /v3/venue/customers/{id}/customer_tags/remove
Body parameter
{
"tag_ids": [
3
]
}
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| body | body | object | false | none |
Example responses
200 Response
{
"customer": {
"id": 1448750,
"first_name": "JANE",
"terms_agreed": false,
"points": 0,
"loyalty": true,
"loyalty_number": "1448750",
"last_name": "",
"birth_year": null,
"gender": "female",
"telephone": "5552655555",
"email": "",
"active": true,
"sms_opt_out": true,
"sms_opt_in": false,
"address": "",
"zipcode": "98119",
"city": "SEATTLE",
"state": "WA",
"birthday": null,
"customer_type": "medical",
"id_expiration": "2032-01-01",
"medical_card_expiration": "2026-01-01",
"drivers_license": "WDLB",
"customer_tags": [
{
"id": 296,
"merchant_id": 7684,
"name": "Industry",
"active": true,
"pos_enabled": true,
"manager_approval": true,
"description": "",
"discount_limit": null,
"taggings_count": 2,
"color": "#d82206",
"created_at": "2023-12-12T20:07:52.000Z",
"updated_at": "2023-12-12T20:08:09.000Z"
}
]
}
}
404 Response
{
"code": 204,
"message": "Cannot find customer"
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 404 | Not Found | Not Found | Inline |
Response Schema
GET customer_queues
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/customer_queues',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/customer_queues', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/customer_queues", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/customer_queues";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/customer_queues \
-H 'Accept: application/json'
GET /v3/venue/customer_queues
Update an existing customer
Example responses
200 Response
{
"total_records": 2,
"current_page": 1,
"total_pages": 1,
"per_page": 50,
"customer_queues": [
{
"queue": 1,
"customer_queue_id": 5355,
"customer_id": 183218,
"user_id": 12507,
"user_name": "Test User",
"name": "John Doe",
"telephone": "",
"birth_year": 1959,
"sms_opt_out": false,
"sms_opt_in": true,
"email": "test@gmail.com",
"source": "walk_in",
"pickup": false,
"created_on": "2024-10-03",
"aasm_state": "open",
"customer_notes": null,
"created_at": "2024-10-03T20:04:14.000Z",
"updated_at": "2024-10-03T20:04:14.000Z",
"processed_at": null,
"saved_order": "",
"saved_order_data": "",
"saved_order_total": ""
},
{
"queue": 2,
"customer_queue_id": 5356,
"customer_id": 183219,
"user_id": 12507,
"user_name": "Test User",
"name": "Jane Doe",
"telephone": "",
"birth_year": 1975,
"sms_opt_out": true,
"sms_opt_in": false,
"email": "test@gmail.com",
"source": "walk_in",
"pickup": false,
"created_on": "2024-10-03",
"aasm_state": "open",
"customer_notes": null,
"created_at": "2024-10-03T20:04:16.000Z",
"updated_at": "2024-10-03T20:04:16.000Z",
"processed_at": null,
"saved_order": "",
"saved_order_data": "",
"saved_order_total": ""
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
GET coupons
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/coupons',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/coupons', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/coupons", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/coupons";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/coupons \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/coupons
Returns a list of discounts and rewards
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET inventories
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/inventories',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/inventories', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/inventories", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/inventories";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/inventories \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/inventories
Returns a list of inventory skus
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET inventories/{id}
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/inventories/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/inventories/{id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/inventories/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/inventories/{id}";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/inventories/{id} \
-H 'Accept: application/json'
GET /v3/venue/inventories/{id}
Returns an inventory sku
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| id | path | integer(int32) | true | Inventory Sku ID |
Example responses
200 Response
{
"id": 107890,
"product_id": 800566,
"name": " zz Panacea - Cherry OG Trim (14g)",
"unit": "14.0 gm",
"price": 1000,
"med_price": null,
"last_price": 5400,
"quantity_on_hand": "95.0",
"sellable_quantity": "94.0",
"ecomm_quantity": "94.0",
"vendor": "Solar Joes",
"vendor_license": "415819",
"brand": "Panacea",
"category": "Flower",
"compliance_type": "Usable Cannabis",
"flower_type": "hybrid",
"concentrate_type": null,
"product_type": "hybrid",
"product_family": "Flower",
"tags": [
"Industry",
"Sale Day"
],
"description": "Double trimmed premium shake bag with Cherry OG, a very balanced hybrid. Great flavors.",
"description_html": "<div>Double <strong>trimmed</strong> premium <em>shake</em> bag with <del>Cherry</del> OG, a very balanced hybrid. Great flavors.</div>",
"image": [
"https://pbit-staging.s3.amazonaws.com/images/image/3194/leaf_2.jpeg"
],
"active": true,
"bulk_item": true,
"strain": "Cherry OG Trim",
"thc_measure": "61.9%",
"thca_measure": "0.0",
"total_thc_measure": "0.0",
"cbd_measure": "5.4%",
"cbda_measure": "0.0",
"total_cbd_measure": "0.0",
"sku": "6033512330004399",
"discountable": true,
"tier_name": "Top Tier",
"doh_compliant": false,
"tier_prices": [
{
"weight": "1.0",
"weight_unit": "grams",
"weight_in_grams": 1,
"price": 1000,
"med_price": null
},
{
"weight": "3.5",
"weight_unit": "grams",
"weight_in_grams": 3.5,
"price": 3000,
"med_price": null
},
{
"weight": "7.0",
"weight_unit": "grams",
"weight_in_grams": 7,
"price": 5500,
"med_price": null
},
{
"weight": "14.0",
"weight_unit": "grams",
"weight_in_grams": 14,
"price": 10000,
"med_price": null
}
],
"terpenes": [],
"effects": [],
"flavors": [],
"images": [
{
"name": "leaf_2.jpeg",
"og": "https://pbit-staging.s3.amazonaws.com/images/image/3194/leaf_2.jpeg",
"lg": "https://pbit-staging.s3.amazonaws.com/images/image/3194/web_leaf_2.jpeg",
"md": "https://pbit-staging.s3.amazonaws.com/images/image/3194/medium_leaf_2.jpeg",
"thumb": "https://pbit-staging.s3.amazonaws.com/images/image/3194/thumb_leaf_2.jpeg",
"is_product_specific_image": true,
"position": 1
},
{
"name": "brand.jpeg",
"og": "https://pbit-staging.s3.amazonaws.com/images/image/2620/brand.jpeg",
"lg": "https://pbit-staging.s3.amazonaws.com/images/image/2620/web_brand.jpeg",
"md": "https://pbit-staging.s3.amazonaws.com/images/image/2620/medium_brand.jpeg",
"thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2620/thumb_brand.jpeg",
"is_product_specific_image": true,
"position": 4
}
],
"created_at": "2018-08-08T18:37:47.000Z",
"updated_at": "2024-12-10T18:54:53.000Z"
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 401 | Unauthorized | Unauthorized | None |
| 404 | Not Found | Inventory not found | None |
Response Schema
PUT inventories/{id}
Code samples
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.put '/v3/venue/inventories/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': 'application/json; charset=utf-8'
}
r = requests.put('/v3/venue/inventories/{id}', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "/v3/venue/inventories/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakePutRequest()
{
int id = 1;
string url = "/v3/venue/inventories/{id}";
var result = await PutAsync(id, null, url);
}
/// Performs a PUT Request
public async Task PutAsync(int id, undefined content, string url)
{
//Serialize Object
StringContent jsonContent = SerializeObject(content);
//Execute PUT request
HttpResponseMessage response = await Client.PutAsync(url + $"/{id}", jsonContent);
//Return response
return await DeserializeObject(response);
}
/// Serialize an object to Json
private StringContent SerializeObject(undefined content)
{
//Serialize Object
string jsonObject = JsonConvert.SerializeObject(content);
//Create Json UTF8 String Content
return new StringContent(jsonObject, Encoding.UTF8, "application/json");
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X PUT /v3/venue/inventories/{id} \
-H 'Content-Type: application/json' \
-H 'Accept: application/json; charset=utf-8'
PUT /v3/venue/inventories/{id}
Update an inventory sku
Body parameter
false
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| id | path | integer(int32) | true | Inventory Sku ID |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
| 404 | Not Found | Inventory not found | None |
| 422 | Unprocessable Entity | No valid attributes to update | None |
Response Schema
GET inventory_tiers
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/inventory_tiers',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/inventory_tiers', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/inventory_tiers", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/inventory_tiers";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/inventory_tiers \
-H 'Accept: application/json'
GET /v3/venue/inventory_tiers
Example responses
200 Response
{
"inventory_tiers": [
{
"id": 1,
"name": "Low Tier",
"weights": [
{
"name": "1g",
"position": 1,
"price": 100,
"med_price": null,
"weight": "1.0",
"weight_unit": "grams",
"weight_in_grams": "1.0"
},
{
"name": "3.5g",
"position": 2,
"price": 180,
"med_price": null,
"weight": "3.5",
"weight_unit": "grams",
"weight_in_grams": "3.5"
},
{
"name": "7",
"position": 6,
"price": 0,
"med_price": null,
"weight": "7.0",
"weight_unit": "grams",
"weight_in_grams": "7.0"
},
{
"name": ".5 oz",
"position": 7,
"price": 500,
"med_price": null,
"weight": "14.0",
"weight_unit": "grams",
"weight_in_grams": "14.0"
},
{
"name": "Weight 8oz",
"position": 8,
"price": 840,
"med_price": null,
"weight": "8.0",
"weight_unit": "ounces",
"weight_in_grams": "45359237/200000"
}
]
},
{
"id": 2,
"name": "Top Tier",
"weights": [
{
"name": "1g",
"position": 1,
"price": 1000,
"med_price": null,
"weight": "1.0",
"weight_unit": "grams",
"weight_in_grams": "1.0"
},
{
"name": "3.5g",
"position": 2,
"price": 3000,
"med_price": null,
"weight": "3.5",
"weight_unit": "grams",
"weight_in_grams": "3.5"
},
{
"name": "7",
"position": 6,
"price": 5500,
"med_price": null,
"weight": "7.0",
"weight_unit": "grams",
"weight_in_grams": "7.0"
},
{
"name": ".5 oz",
"position": 7,
"price": 10000,
"med_price": null,
"weight": "14.0",
"weight_unit": "grams",
"weight_in_grams": "14.0"
},
{
"name": "Weight 8oz",
"position": 8,
"price": 30000,
"med_price": null,
"weight": "8.0",
"weight_unit": "ounces",
"weight_in_grams": "45359237/200000"
}
]
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
GET inventory_transactions
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/inventory_transactions',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/inventory_transactions', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/inventory_transactions", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/inventory_transactions";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/inventory_transactions \
-H 'Accept: application/json'
GET /v3/venue/inventory_transactions
Returns a list of inventory transactions
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| q[manifest_item_id_eq] | query | integer(int32) | false | Specify manifest item id |
| q[transaction_type_eq] | query | string | false | Query by transaction type |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| q[order_id_eq] | query | integer(int32) | false | Specify order id |
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
Example responses
200 Response
{
"total_records": 116327,
"current_page": 1,
"total_pages": 116327,
"per_page": 1,
"inventory_transactions": [
{
"id": 8984553,
"manifest_item_id": 178188,
"sku_id": 107893,
"transaction_type": "purchase",
"order_id": 178188,
"order_type": "ManifestItem",
"quantity": "5.0",
"reason": "auto replenish",
"updated_by": null,
"note": null,
"cost_diff": 1000,
"previous_cost": 2000,
"updated_cost": 3000,
"previous_quantity": 3791,
"updated_quantity": 3796,
"created_at": "2024-02-22",
"updated_at": "2024-02-22T10:37:02.000Z"
}
]
}
401 Response
{
"message": "Invalid Token"
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
| 401 | Unauthorized | Unauthorized | Inline |
Response Schema
Response Headers
| Status | Header | Type | Format | Description |
|---|---|---|---|---|
| 401 | Access-Control-Allow-Origin | string | none | |
| 401 | Access-Control-Request-Method | string | none | |
| 401 | Cache-Control | string | none | |
| 401 | Content-Type | string | none | |
| 401 | Date | string | none | |
| 401 | Server | string | none | |
| 401 | Status | string | none | |
| 401 | X-Request-Id | string | none | |
| 401 | Content-Length | integer | none | |
| 401 | Connection | string | none |
GET manifests
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/manifests',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/manifests', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/manifests", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/manifests";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/manifests \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/manifests
Returns a list of manifests and its manifest items
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| q[aasm_state_eq] | query | string | false | Query for manifests in a specified state |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET manifest_items
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/manifest_items',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/manifest_items', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/manifest_items", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/manifest_items";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/manifest_items \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/manifest_items
Returns a list of manifest items
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| q[aasm_state_eq] | query | string | false | Query for manifest items in a specified state |
| q[quantity_on_hand_gt] | query | integer(int32) | false | Query for manifest items where quantity on hand is greater than |
| q[quantity_on_hand_lt] | query | integer(int32) | false | Query for manifest items where quantity on hand is less than |
| q[quantity_on_hand_eq] | query | integer(int32) | false | Query for manifest items where quantity on hand equals |
Example responses
200 Response
{
"total_records": 208,
"current_page": 1,
"total_pages": 208,
"per_page": 1,
"manifest_items": [
{
"id": 261878,
"manifest_id": null,
"state": "active",
"supplier_quantity": "365.0",
"accepted_quantity": "365.0",
"quantity_on_hand": "369.7",
"pre_return_quantity": null,
"cost_per_unit": 300,
"inventory_id": 210113,
"lot_number": "WAR414871.IN6BJ9N",
"barcode": "WAJ416063.IN6AEJ2",
"batch_number": null,
"last_audit": null,
"venue_room": "Display Case 3",
"harvest_date": null,
"thc_measure": "21.5%",
"cbd_measure": "0.7%",
"coa_url": null,
"created_at": "2019-10-16T20:37:50.000Z",
"updated_at": "2022-06-27T21:25:45.000Z"
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET product_brands
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/product_brands',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/product_brands', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/product_brands", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/product_brands";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/product_brands \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/product_brands
Returns a list of product brands
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET product_tags
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/product_tags',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/product_tags', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/product_tags", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/product_tags";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/product_tags \
-H 'Accept: application/json'
GET /v3/venue/product_tags
Update an existing customer
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer | false | none |
| per_page | query | integer | false | none |
Example responses
200 Response
{
"total_records": 510,
"current_page": 1,
"total_pages": 510,
"per_page": 1,
"product_tags": [
{
"id": 26439,
"merchant_id": 7684,
"venue_id": null,
"name": "$1offlighter",
"active": true,
"pos_enabled": true,
"description": null,
"taggings_count": 16,
"created_at": "2023-07-31T17:29:33.000Z",
"updated_at": "2023-07-31T17:29:34.000Z",
"color": "#674E21",
"qr_code": {
"url": "https://pbit-staging.s3.amazonaws.com/uploads/ptag_26439.png"
}
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
GET product_types
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/product_types',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/product_types', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/product_types", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/product_types";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/product_types \
-H 'Accept: application/json'
GET /v3/venue/product_types
Update an existing customer
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer | false | none |
| per_page | query | integer | false | none |
Example responses
200 Response
{
"total_records": 90,
"current_page": 1,
"total_pages": 18,
"per_page": 5,
"product_types": [
{
"id": 3673,
"name": "Default",
"description": null,
"created_at": "2018-08-08T17:28:52.000Z",
"updated_at": "2023-01-06T17:08:09.000Z",
"is_marijuana": true,
"weighable": false,
"family_id": 2,
"family_name": "Flower"
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
GET product_strains
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/product_strains',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/product_strains', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/product_strains", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/product_strains";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/product_strains \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/product_strains
Returns a list of product strains
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| q[used_eq] | query | integer(int32) | false | Filter if product strain is used |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET return_manifests
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/return_manifests',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/return_manifests', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/return_manifests", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/return_manifests";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/return_manifests \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/return_manifests
Returns a list of return manifests
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| q[aasm_state_eq] | query | string | false | Query for manifests in a specified state |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET venue_rooms
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get '/v3/venue/venue_rooms',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json'
}
r = requests.get('/v3/venue/venue_rooms', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/venue_rooms", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/venue_rooms";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/venue_rooms \
-H 'Accept: application/json'
GET /v3/venue/venue_rooms
Update an existing customer
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer | false | none |
| per_page | query | integer | false | none |
Example responses
200 Response
{
"total_records": 11,
"current_page": 1,
"total_pages": 4,
"per_page": 3,
"venue_rooms": [
{
"id": 14,
"name": "Drawer #1",
"pos_visible": true,
"description": "",
"color": "#00ADEE",
"created_at": "2018-08-13T20:55:54.000Z",
"updated_at": "2024-06-24T20:52:17.000Z",
"ecommerce_visible": true
},
{
"id": 15,
"name": "Drawer #2",
"pos_visible": true,
"description": "",
"color": "#ffd966",
"created_at": "2018-08-13T20:56:08.000Z",
"updated_at": "2022-04-18T20:31:22.000Z",
"ecommerce_visible": true
},
{
"id": 16,
"name": "Drawer #3",
"pos_visible": true,
"description": "",
"color": "#f9cb9c",
"created_at": "2018-08-13T21:01:17.000Z",
"updated_at": "2022-04-18T20:31:22.000Z",
"ecommerce_visible": true
}
]
}
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | Inline |
Response Schema
GET sales_histories
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/sales_histories',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/sales_histories', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/sales_histories", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/sales_histories";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/sales_histories \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/sales_histories
Returns a list of sales history
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[ordered_at_gt] | query | string | false | Filter sales where ordered date is greater than |
| q[ordered_at_lt] | query | string | false | Filter sales where ordered date is less than |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET suppliers
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/suppliers',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/suppliers', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/suppliers", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/suppliers";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/suppliers \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/suppliers
Returns a list of suppliers
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| q[used_eq] | query | integer(int32) | false | Filter suppliers that are in use |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET terminal_tills
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/terminal_tills',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/terminal_tills', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/terminal_tills", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/terminal_tills";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/terminal_tills \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/terminal_tills
Returns a list of terminal tills
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[s] | query | string | false | Specify field to query |
| q[aasm_state_eq] | query | string | false | Filter tills in specified state |
| q[terminal_id_eq] | query | integer(int32) | false | Filter by terminal id |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET transfer_manifests
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/transfer_manifests',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/transfer_manifests', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/transfer_manifests", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/transfer_manifests";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/transfer_manifests \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/transfer_manifests
Returns a list of transfer manifests
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| page | query | integer(int32) | false | Page number |
| per_page | query | integer(int32) | false | Records per page |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
| q[aasm_state_eq] | query | string | false | Query for manifests in a specified state |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
GET users
Code samples
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json; charset=utf-8'
}
result = RestClient.get '/v3/venue/users',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json; charset=utf-8'
}
r = requests.get('/v3/venue/users', headers = headers)
print(r.json())
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json; charset=utf-8"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "/v3/venue/users", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
/// <<summary>>
/// Example of Http Client
/// <</summary>>
public class HttpExample
{
private HttpClient Client { get; set; }
/// <<summary>>
/// Setup http client
/// <</summary>>
public HttpExample()
{
Client = new HttpClient();
}
/// Make a dummy request
public async Task MakeGetRequest()
{
string url = "/v3/venue/users";
var result = await GetAsync(url);
}
/// Performs a GET Request
public async Task GetAsync(string url)
{
//Start the request
HttpResponseMessage response = await Client.GetAsync(url);
//Validate result
response.EnsureSuccessStatusCode();
}
/// Deserialize object from request response
private async Task DeserializeObject(HttpResponseMessage response)
{
//Read body
string responseBody = await response.Content.ReadAsStringAsync();
//Deserialize Body to object
var result = JsonConvert.DeserializeObject(responseBody);
}
}
# You can also use wget
curl -X GET /v3/venue/users \
-H 'Accept: application/json; charset=utf-8'
GET /v3/venue/users
Returns a list of users
Parameters
| Name | In | Type | Required | Description |
|---|---|---|---|---|
| per_page | query | integer(int32) | false | Records per page |
| page | query | integer(int32) | false | Page number |
| q[updated_at_gt] | query | string | false | Filter by updates since provided date |
| q[updated_at_lt] | query | string | false | Filter by updates prior to the provided date |
Example responses
Responses
| Status | Meaning | Description | Schema |
|---|---|---|---|
| 200 | OK | OK | None |
| 401 | Unauthorized | Unauthorized | None |
Response Schema
Schemas
IncomingOrders
{
"code": 1,
"incoming_order": {
"id": 1857,
"aasm_state": "pending",
"reference_no": "123456",
"first_name": "Snoop",
"last_name": "Dogg",
"source": "online_store",
"order_type": "pickup",
"notes": null,
"delivered_at": null,
"requested_date": null,
"requested_window_start_time": {},
"requested_window_end_time": {},
"requested_payment_method": "debit",
"payment_verified": false,
"created_at": "2022-07-27T23:32:45.000Z",
"updated_at": "2022-07-27T23:32:45.000Z"
},
"order_items": [
{
"item_id": 3270,
"product_id": 900835,
"sku_id": null,
"manifest_item_id": null,
"product_name": "Blazin' - 9lb Hammer - 3.5g",
"product_brand": "Trail Blazin'",
"product_strain": "9lb Hammer",
"weight": null,
"quantity": 2,
"unit_quantity": "2.0",
"price": 0,
"discount": null,
"tax": null,
"tier_weight_id": null,
"coupons": [],
"taxes": [],
"created_at": "2022-07-27T23:32:45.000Z",
"updated_at": "2022-07-27T23:32:45.000Z"
},
{
"item_id": 3271,
"product_id": 900875,
"sku_id": null,
"manifest_item_id": null,
"product_name": "Honu - Peanut Butter Cup Sativa 10pk (100mg)",
"product_brand": "Honu",
"product_strain": "Mixed",
"weight": null,
"quantity": 2,
"unit_quantity": "2.0",
"price": 0,
"discount": null,
"tax": null,
"tier_weight_id": null,
"coupons": [],
"taxes": [],
"created_at": "2022-07-27T23:32:45.000Z",
"updated_at": "2022-07-27T23:32:45.000Z"
}
]
}
/v3/incoming_orders Response
Properties
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| code | integer(int32) | true | none | none |
| incoming_order | array | true | none | Incoming order description |
| » id | integer(int32) | false | none | Incoming order ID |
| » aasm_state | string | false | none | State of incoming order |
| » reference_no | string | false | none | Reference number |
| » first_name | string | false | none | Customer first name |
| » last_name | string | false | none | Customer last name |
| » source | string | false | none | Order source |
| » order_type | string | false | none | Order type |
| » notes | string¦null | false | none | Order notes |
| » delivered_at | string¦null | false | none | Delivered at datetime |
| » requested_date | string¦null | false | none | Requested date |
| » requested_window_start_time | object | false | none | Requested window start time |
| » requested_window_end_time | object | false | none | Requested window end time |
| » requested_payment_method | string¦null | false | none | Requested payment method |
| » payment_verified | boolean | false | none | Boolean payment verified |
| » created_at | string | false | none | Created at datetime |
| » updated_at | string | false | none | Updated at datetime |
| order_items | array | true | none | Order items description |
| » item_id | integer(int32) | false | none | Order item ID |
| » product_id | integer(int32) | false | none | Product ID |
| » sku_id | integer(int32) | false | none | Inventory sku ID |
| » manifest_item_id | integer(int32) | false | none | Manifest item ID |
| » product_name | string | false | none | Product name |
| » product_brand | string | false | none | Product brand |
| » product_strain | string | false | none | Product strain |
| » weight | string¦null | false | none | Item weight |
| » quantity | integer(int32) | false | none | Item quantity |
| » unit_quantity | string | false | none | Item unit quantity |
| » price | integer(int32) | false | none | Item price |
| » discount | string¦null | false | none | Item discount |
| » tax | string¦null | false | none | Item tax |
| » tier_weight_id | string¦null | false | none | Item tier weight ID |
| » coupons | [string] | false | none | List of coupons applied to item |
| » taxes | [string] | false | none | List of taxes applied to item |
| » created_at | string | false | none | Created at datetime |
| » updated_at | string | false | none | Updated at datetime |
IncomingOrdersRequest
{
"incoming_order": {
"order_type": "pickup",
"source": "online_store",
"first_name": "Snoop",
"last_name": "Dogg",
"email": "bluedream@deathrow.com",
"telephone": "5551111112",
"address": "",
"city": "",
"state_abbrev": "",
"zipcode": "",
"reference_no": "123456",
"requested_payment_method": "debit",
"order_items_attributes": [
{
"product_parent_id": "Blazin' - 9lb Hammer - 3.5g",
"product_id": 900835,
"product_name": "Blazin' - 9lb Hammer - 3.5g",
"product_brand": "Trail Blazin'",
"product_strain": "9lb Hammer",
"weight": null,
"price": 4000,
"quantity": 2
},
{
"product_parent_id": "Lemon Meringue - Avitas - Flower",
"product_id": 900875,
"product_name": "Honu - Peanut Butter Cup Sativa 10pk (100mg)",
"product_brand": "Honu",
"product_strain": "Mixed",
"weight": null,
"price": 2999,
"quantity": 2
}
],
"payment_prepaid": true,
"payment_source": "posabit",
"payment_reference_id": "12345",
"payment_amount": 13500
}
}
/v3/incoming_orders Request
Properties
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| incoming_order | object | true | none | none |
| » order_type | string | false | none | Order type |
| » source | string | false | none | Order source |
| » first_name | string | false | none | Customer first name |
| » last_name | string | false | none | Customer last name |
| string | false | none | Customer email | |
| » telephone | string | false | none | Customer phone number |
| » address | string | false | none | Customer street address |
| » city | string | false | none | Customer city |
| » state_abbrev | string | false | none | Customer state |
| » zipcode | string | false | none | Customer zip code |
| » reference_no | string | false | none | Order reference number |
| » requested_payment_method | string | false | none | Requested payment method |
| » order_items_attributes | array | false | none | Order items description |
| »» product_parent_id | string | false | none | Product name |
| »» product_id | integer(int32) | false | none | Product ID |
| »» product_name | string | false | none | Product name |
| »» product_brand | string | false | none | Product brand |
| »» product_strain | string | false | none | Product strain |
| »» weight | string¦null | false | none | If weighable, product weight |
| »» price | integer(int32) | false | none | Product price |
| »» quantity | integer(int32) | false | none | Quantity to purchase |
| » payment_prepaid | boolean | false | none | Boolean if order is prepaid |
| » payment_source | string | false | none | Payment source |
| » payment_reference_id | string | false | none | Payment reference ID |
| » payment_amount | integer(int32) | false | none | Total payment amount |
IncomingQuote
{
"code": 1,
"incoming_quote": {
"id": 56,
"reference_no": "REF_NO_1",
"subtotal": 1168,
"tax": 332,
"discount": 500,
"total": 1500,
"telephone": "5551111112",
"customer_id": 279161,
"created_at": "2022-07-22T20:57:40.000Z",
"updated_at": "2022-07-22T20:57:40.000Z",
"quote_items": [
{
"item_id": 91,
"inventory_sku_id": 214772,
"product_id": 907088,
"product_name": "Freddy's Fuego - Washington Apple Bulk",
"quantity": 2,
"unit_quantity": "14.0",
"price": null,
"discount": 500,
"tax": 0,
"weight": "7g",
"tier_weight": null,
"coupons": [
{
"id": 20,
"quote_item_id": 91,
"pos_coupon_id": null,
"ref_number": "1234",
"ref_name": "discount",
"amount": 500,
"created_at": "2022-07-22T20:57:40.000Z",
"updated_at": "2022-07-22T20:57:40.000Z"
}
],
"taxes": [
{
"id": 116,
"tax_id": 4324,
"name": "Oregon Marijuana Tax",
"price_included": true,
"amount": 0,
"created_at": "2022-07-22T20:57:40.000Z",
"updated_at": "2022-07-22T20:57:40.000Z"
},
{
"id": 117,
"tax_id": 4325,
"name": "Portland Marijuana Tax",
"price_included": true,
"amount": 0,
"created_at": "2022-07-22T20:57:40.000Z",
"updated_at": "2022-07-22T20:57:40.000Z"
}
]
}
]
}
}
/v3/incoming_quotes GET Response
Properties
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| code | integer(int32) | true | none | none |
| incoming_quote | object | true | none | none |
| » id | integer(int32) | false | none | Incoming quote ID |
| » reference_no | string | false | none | Reference number |
| » subtotal | integer(int32) | false | none | Incoming quote subtotal |
| » tax | integer(int32) | false | none | Quote tax amount |
| » discount | integer(int32) | false | none | Quote discount amount |
| » total | integer(int32) | false | none | Quote total amount |
| » telephone | string | false | none | Customer phone number |
| » customer_id | integer(int32) | false | none | Customer ID |
| » created_at | string | false | none | Created at datetime |
| » updated_at | string | false | none | Updated at datetime |
| » quote_items | array | false | none | Incoming Quote items |
| »» item_id | integer(int32) | false | none | Incoming quote item ID |
| »» inventory_sku_id | integer(int32) | false | none | Inventory sku ID |
| »» product_id | integer(int32) | false | none | Product ID |
| »» product_name | string | false | none | Product name |
| »» quantity | integer(int32) | false | none | Item quantity |
| »» unit_quantity | string | false | none | Item unit quantity |
| »» price | integer(int32) | false | none | Item price pre tax |
| »» discount | string¦null | false | none | Item discount |
| »» tax | integer(int32) | false | none | Item tax |
| »» weight | string¦null | false | none | Item weight |
| »» tier_weight | string¦null | false | none | Item tier weight |
| »» coupons | [any] | false | none | List of coupons applied to item |
| »»» id | integer(int32) | false | none | Incoming quote item discount ID |
| »»» quote_item_id | integer(int32) | false | none | Incoming quote item ID |
| »»» pos_coupon_id | string¦null | false | none | Discount ID |
| »»» ref_number | string | false | none | Reference number |
| »»» ref_name | string | false | none | Discount reference name |
| »»» amount | integer(int32) | false | none | Discount amount |
| »»» created_at | string | false | none | Created at datetime |
| »»» updated_at | string | false | none | Updated at datetime |
| »» taxes | array | false | none | Tax description |
| »»» id | integer(int32) | false | none | Incoming quote item tax ID |
| »»» tax_id | integer(int32) | false | none | Tax ID |
| »»» name | string | false | none | Tax name |
| »»» price_included | boolean | false | none | Boolean if tax is included in price |
| »»» amount | integer(int32) | false | none | Tax amount |
| »»» created_at | string | false | none | Created at datetime |
| »»» updated_at | string | false | none | Updated at datetime |
Info
{
"code": 0,
"venues": [],
"example": null
}
/v3/info Response
Properties
| Name | Type | Required | Restrictions | Description |
|---|---|---|---|---|
| code | integer(int32) | true | none | none |
| venues | array | false | none | none |
| » venue_name | string | false | none | Venue Name |
| » active | boolean | false | none | Status of the integration |
| » venue_token | string | false | none | Venue API Token |
| » first_connected_date | string | false | none | Date of first API request |
| » last_connected_date | string | false | none | Date of last API request |
| example | any | false | none | none |