NAV
Ruby Python Go C# curl

Payments

Point of sale

POSaBIT

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.

Setup

Run in Postman

Base URL:

Staging Env Production Env
https://staging-app.posabit.com/api https://app.posabit.com/api

Requirements

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.

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/v1/menu_feeds/9e9cbb53-348e-407c-a5cc-fca9a3e6c336

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/v1/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/v1/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": {
    "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:

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

API

GET {token} info

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/{venue_token}/v1/info',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/{venue_token}/v1/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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/info \
  -H 'Accept: application/json'

GET /{venue_token}/v1/info

Parameters

Name In Type Required Description
venue_token path string true none

Example responses

200 Response

{
  "code": 1,
  "name": "The Bong Marché",
  "license": "C11-0001157-LIC",
  "region": "Washington State",
  "locale": "en-US",
  "vertical": "dispensaries",
  "logo_thumb": "https://pbit-qa.s3.amazonaws.com/logos/Venue/thumb_3221_logo.png",
  "logo_medium": "https://pbit-qa.s3.amazonaws.com/logos/Venue/medium_3221_logo.png",
  "telephone": "5556543211",
  "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": 1000,
      "tax_rate": "10.0",
      "price_included": true
    },
    {
      "id": 4286,
      "name": "Bellingham, WA",
      "rate": 837,
      "tax_rate": "8.375",
      "price_included": true
    },
    {
      "id": 4415,
      "name": "Excise tax",
      "rate": 1500,
      "tax_rate": "15.0",
      "price_included": true
    }
  ],
  "payment_methods": [
    "Cash",
    "POSaBIT Pay",
    "Debit Card",
    "Other"
  ],
  "venue_settings": {
    "online_order_curbside": "1",
    "online_order_delivery": "0"
  }
}

401 Response

{
  "message": "Invalid Token"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized Inline

Response Schema

GET {token} coupons

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/{venue_token}/v1/coupons',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/{venue_token}/v1/coupons', 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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/coupons \
  -H 'Accept: application/json'

GET /{venue_token}/v1/coupons

Parameters

Name In Type Required Description
venue_token path string true none

Example responses

200 Response

{
  "code": 1,
  "total_records": 111,
  "current_page": 1,
  "total_pages": 4,
  "per_page": 30,
  "coupons": [
    {
      "id": 47370,
      "name": "B - Student 5% Off",
      "display_name": "B - Student 5% Off",
      "kind": "discount",
      "amount": 500,
      "coupon_type": "percent",
      "applies_to": "order",
      "auto_apply": false,
      "customer_type": ""
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

POST {token} incoming_orders

Code samples

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '/{venue_token}/v1/incoming_orders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/{venue_token}/v1/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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/incoming_orders \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /{venue_token}/v1/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 '/{venue_token}/v1/incoming_orders/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/{venue_token}/v1/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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/incoming_orders/{id} \
  -H 'Accept: application/json'

GET /{venue_token}/v1/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 '/{venue_token}/v1/incoming_quotes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('/{venue_token}/v1/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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/incoming_quotes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST /{venue_token}/v1/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

GET {token} incoming_quotes/{id}

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/{venue_token}/v1/incoming_quotes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/{venue_token}/v1/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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/incoming_quotes/{id} \
  -H 'Accept: application/json'

GET /{venue_token}/v1/incoming_quotes/{id}

Parameters

Name In Type Required Description
venue_token path string true none
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

PUT {token} incoming_quotes

Code samples

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.put '/{venue_token}/v1/incoming_quotes/{reference_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.put('/{venue_token}/v1/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", "/{venue_token}/v1/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 = "/{venue_token}/v1/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 /{venue_token}/v1/incoming_quotes/{reference_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /{venue_token}/v1/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 menu_feeds

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v1/menu_feeds/{feed_key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v1/menu_feeds/{feed_key}', 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", "/v1/menu_feeds/{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 = "/v1/menu_feeds/{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 /v1/menu_feeds/{feed_key} \
  -H 'Accept: application/json'

GET /v1/menu_feeds/{feed_key}

Parameters

Name In Type Required Description
feed_key path string true none

Example responses

200 Response

{
  "menu_feed": {
    "title": "Test Menu Feed",
    "feed_key": "aebbfb2a-27a2-4d96-a357-94d23794215e",
    "description": "",
    "feed_type": "posabit menu",
    "menu_groups": [
      {
        "name": "Flower",
        "category_guid": "Tlzs2pMnHzR47C5OIUwC7w",
        "name_template": "name",
        "combine_weights": true,
        "description": "",
        "image": {
          "is_default": true,
          "og": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "lg": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "md": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "sm": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png"
        },
        "menu_items": [
          {
            "id": "(C) Gorilla Glue - Phat Panda - Flower",
            "guid": "104e4ca0-d909-468d-8623-9ad184602590",
            "name": "Sour Super Haze Alien Fruity Pebble",
            "description": "Gets you high.",
            "is_medical_only": false,
            "tag_list": [
              "Sale Day",
              "Item Box Test"
            ],
            "flower_type": "sativa",
            "brand": "Phat Panda",
            "strain": "(C) Gorilla Glue",
            "terpenes": [
              "Caryophyllene"
            ],
            "effects": [],
            "flavors": [],
            "product_type": "Flower",
            "is_marijuana": true,
            "tier_name": "Test tier ",
            "brand_logo": {
              "is_default": true,
              "og": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "lg": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "md": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "sm": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png"
            },
            "product_image": {
              "is_default": false,
              "is_product_specific_image": false,
              "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
              "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "sm": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
              "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
            },
            "product_image_v2": {
              "is_default": false,
              "is_product_specific_image": false,
              "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
              "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "sm": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
              "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
            },
            "images": [
              {
                "name": "Flower",
                "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
                "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/web_image.jpg",
                "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
                "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
              },
              {
                "name": "flower 2.png",
                "og": "https://pbit-staging.s3.amazonaws.com/images/image/2611/flower_2.png",
                "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2611/web_flower_2.png",
                "md": "https://pbit-staging.s3.amazonaws.com/images/image/2611/medium_flower_2.png",
                "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2611/thumb_flower_2.png"
              }
            ],
            "prices": [
              {
                "id": "855277_Test tier_1g",
                "name": "Sour Super Haze Alien Fruity Pebble",
                "price_cents": 1500,
                "med_price_cents": null,
                "unit": "1.0",
                "unit_type": "grams",
                "quantity_on_hand": "4952.0",
                "equivalent_weight": null,
                "equivalent_unit": null,
                "supplier": "POSaBIT Producer/Processor"
              }
            ],
            "thc": {
              "current": "20.0",
              "low": "20.0",
              "high": "20.0",
              "unit_type": "%"
            },
            "cbd": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "thca": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "cbda": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "total_thc": {
              "current": 20,
              "low": 20,
              "high": 20,
              "unit_type": "%"
            }
          }
        ]
      }
    ]
  }
}

404 Response

{
  "error": "Could not find menu feed"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
404 Not Found Not Found Inline

Response Schema

GET {token} menu_feeds v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/{venue_token}/v2/menu_feeds/{feed_key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/{venue_token}/v2/menu_feeds/{feed_key}', 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", "/{venue_token}/v2/menu_feeds/{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 = "/{venue_token}/v2/menu_feeds/{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 /{venue_token}/v2/menu_feeds/{feed_key} \
  -H 'Accept: application/json'

GET /{venue_token}/v2/menu_feeds/{feed_key}

Parameters

Name In Type Required Description
venue_token path string true none
feed_key path string true none

Example responses

200 Response

{
  "menu_feed": {
    "title": "Test Menu Feed",
    "feed_key": "aebbfb2a-27a2-4d96-a357-94d23794215e",
    "description": "",
    "feed_type": "posabit menu",
    "menu_groups": [
      {
        "name": "Flower",
        "category_guid": "Tlzs2pMnHzR47C5OIUwC7w",
        "name_template": "name",
        "combine_weights": true,
        "description": "",
        "image": {
          "is_default": true,
          "og": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "lg": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "md": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "sm": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png"
        },
        "menu_items": [
          {
            "id": "(C) Gorilla Glue - Phat Panda - Flower",
            "guid": "104e4ca0-d909-468d-8623-9ad184602590",
            "name": "Sour Super Haze Alien Fruity Pebble",
            "description": "Gets you high.",
            "is_medical_only": false,
            "tag_list": [
              "Sale Day",
              "Item Box Test"
            ],
            "flower_type": "sativa",
            "brand": "Phat Panda",
            "strain": "(C) Gorilla Glue",
            "terpenes": [
              "Caryophyllene"
            ],
            "effects": [],
            "flavors": [],
            "product_type": "Flower",
            "is_marijuana": true,
            "tier_name": "Test tier ",
            "brand_logo": {
              "is_default": true,
              "og": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "lg": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "md": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "sm": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png"
            },
            "product_image": {
              "is_default": false,
              "is_product_specific_image": false,
              "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
              "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "sm": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
              "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
            },
            "product_image_v2": {
              "is_default": false,
              "is_product_specific_image": false,
              "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
              "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "sm": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
              "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
            },
            "images": [
              {
                "name": "Flower",
                "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
                "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/web_image.jpg",
                "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
                "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
              },
              {
                "name": "flower 2.png",
                "og": "https://pbit-staging.s3.amazonaws.com/images/image/2611/flower_2.png",
                "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2611/web_flower_2.png",
                "md": "https://pbit-staging.s3.amazonaws.com/images/image/2611/medium_flower_2.png",
                "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2611/thumb_flower_2.png"
              }
            ],
            "prices": [
              {
                "id": "855277_Test tier _Weight 8oz",
                "name": "Sour Super Haze Alien Fruity Pebble",
                "price_cents": 160000,
                "med_price_cents": null,
                "unit": "8.0",
                "unit_type": "ounces",
                "quantity_on_hand": "4952.0",
                "equivalent_weight": null,
                "equivalent_unit": null,
                "supplier": "POSaBIT Producer/Processor"
              }
            ],
            "thc": {
              "current": "20.0",
              "low": "20.0",
              "high": "20.0",
              "unit_type": "%"
            },
            "cbd": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "thca": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "cbda": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "total_thc": {
              "current": 20,
              "low": 20,
              "high": 20,
              "unit_type": "%"
            }
          }
        ]
      }
    ]
  }
}

404 Response

{
  "error": "Could not find menu feed"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
404 Not Found Not Found Inline

Response Schema

POST incoming_quotes

Code samples

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.post '/v1/incoming_quotes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json; charset=utf-8'
}

r = requests.post('/v1/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; charset=utf-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/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 = "/v1/incoming_quotes";

      string json = @"{
  ""incoming_quote"": {
    ""reference_no"": ""REF_NO_1"",
    ""telephone"": ""555-111-1112"",
    ""quote_items_attributes"": [
      {
        ""inventory_sku_id"": 214772,
        ""quantity"": 2,
        ""weight"": ""7g"",
        ""quote_item_coupons_attributes"": [
          {
            ""amount"": 500,
            ""ref_number"": 1234,
            ""ref_name"": ""discount""
          }
        ]
      },
      {
        ""inventory_sku_id"": 214604,
        ""quantity"": 2
      }
    ]
  }
}";
      IncomingQuoteRequest content = JsonConvert.DeserializeObject(json);
      await PostAsync(content, url);


    }

    /// Performs a POST Request
    public async Task PostAsync(IncomingQuoteRequest 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(IncomingQuoteRequest 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 /v1/incoming_quotes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=utf-8'

POST /v1/incoming_quotes

Create a new incoming quote

Body parameter

{
  "incoming_quote": {
    "reference_no": "REF_NO_1",
    "telephone": "555-111-1112",
    "quote_items_attributes": [
      {
        "inventory_sku_id": 214772,
        "quantity": 2,
        "weight": "7g",
        "quote_item_coupons_attributes": [
          {
            "amount": 500,
            "ref_number": 1234,
            "ref_name": "discount"
          }
        ]
      },
      {
        "inventory_sku_id": 214604,
        "quantity": 2
      }
    ]
  }
}

Parameters

Name In Type Required Description
body body IncomingQuoteRequest true none

Example responses

200 Response

{
  "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"
          }
        ]
      }
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK OK IncomingQuote
401 Unauthorized Unauthorized Unauthorized
422 Unprocessable Entity Invalid parameters None
500 Internal Server Error Internal Server Error None

GET incoming_quotes/{id}

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/incoming_quotes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/incoming_quotes/{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", "/v1/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 = "/v1/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 /v1/incoming_quotes/{id} \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/incoming_quotes/{id}

Returns an incoming quote by id

Parameters

Name In Type Required Description
id path integer(int32) true Incoming Qutoe ID

Example responses

200 Response

{
  "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"
          }
        ]
      }
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK OK IncomingQuote
401 Unauthorized Unauthorized Unauthorized

GET customers v1

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/venue/customers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/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", "/v1/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 = "/v1/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 /v1/venue/customers \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/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

Example responses

200 Response

{
  "total_records": 475,
  "current_page": 1,
  "total_pages": 475,
  "per_page": 1,
  "customers": [
    {
      "customerId": 279159,
      "firstName": "JANE",
      "created_at": "2019-10-21T20:21:19.000Z",
      "updated_at": "2021-10-05T19:31:24.000Z",
      "birthyear": 1992,
      "gender": "female",
      "phone": "5551111111"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK CustomerResponseV1
401 Unauthorized Unauthorized Unauthorized

GET employees v1

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/venue/employees',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/venue/employees', 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", "/v1/venue/employees", 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 = "/v1/venue/employees";
      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 /v1/venue/employees \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/venue/employees

Returns a list of employees

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

Example responses

200 Response

{
  "total_records": 1,
  "current_page": 1,
  "total_pages": 1,
  "per_page": 1,
  "employees": [
    {
      "employeeId": 12998,
      "firstName": "Jane",
      "created_at": "2022-04-21T22:41:04.000Z",
      "updated_at": "2022-04-21T22:41:04.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK EmployeeResponse
401 Unauthorized Unauthorized Unauthorized

GET inventories v1

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/venue/inventories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/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", "/v1/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 = "/v1/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 /v1/venue/inventories \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/venue/inventories

Returns a list of inventory skus

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

Example responses

200 Response

{
  "total_records": 1182,
  "current_page": 1,
  "total_pages": 1182,
  "per_page": 1,
  "products": [
    {
      "productId": 210111,
      "name": "High Five Farms - Ghost Train Haze",
      "unit": "280.0 gm",
      "price": 1300,
      "quantityInStock": "0.0",
      "vendor": "High Five Farms",
      "vendor_license": null,
      "brand": "High Five Farms",
      "category": "Bulk Flower",
      "flowertype": "hybrid",
      "concentratetype": null,
      "producttype": "hybrid",
      "productfamily": "Flower",
      "description": "Conducive to concentration and creativity, this sati...",
      "image": [
        null
      ],
      "active": false,
      "bulkitem": true,
      "strain": "Ghost Train Haze",
      "thcMeasure": "0.0%",
      "cbdMeasure": "0.0%",
      "sku": "3264-902427",
      "discountable": true,
      "rooms": [],
      "created_at": "2019-10-16T20:37:49.000Z",
      "updated_at": "2022-06-14T19:37:38.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK InventoriesResponseV1
401 Unauthorized Unauthorized Unauthorized

GET manifest_items v1

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/venue/manifest_items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/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", "/v1/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 = "/v1/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 /v1/venue/manifest_items \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/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

Example responses

200 Response

{
  "total_records": 1325,
  "current_page": 1,
  "total_pages": 1325,
  "per_page": 1,
  "restocks": [
    {
      "restockId": 261876,
      "parent_id": null,
      "utcDate": "2019-10-16T20:37:49.000Z",
      "quantity": "396.0",
      "quantityInStock": "-1755.422",
      "costPerUnit": 275,
      "productId": 210111,
      "inventoryId": "WAR414871.IN5SAJM",
      "thcMeasure": "19.2%",
      "cbdMeasure": "0.0%",
      "created_at": "2019-10-16T20:37:49.000Z",
      "updated_at": "2022-06-14T19:37:31.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK ManifestItemsResponseV1
401 Unauthorized Unauthorized Unauthorized

GET sales_histories v1

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/venue/sales_histories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/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", "/v1/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 = "/v1/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 /v1/venue/sales_histories \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/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[updated_at_gt] query string false Filter by updates since provided date

Example responses

200 Response

{
  "total_records": 197,
  "current_page": 1,
  "total_pages": 197,
  "per_page": 1,
  "tickets": [
    {
      "ticketId": 49052949,
      "isMedical": true,
      "utcDate": "2022-01-14T23:52:34.000Z",
      "localTime": "2022-01-14T15:52:34.000-08:00",
      "ticketType": "sale",
      "customerId": 279560,
      "employeeId": 12777,
      "paymentType": "",
      "subTotal": 9498,
      "discount": 1900,
      "tax": 0,
      "total": 7857,
      "items": [
        {
          "ticketItemId": 91311967,
          "ticketId": 49052949,
          "productId": 318604,
          "inventoryId": "WAR421642.INOLNTM",
          "quantity": 1,
          "weight": "1.0",
          "cost": 800,
          "subTotal": 2500,
          "tax": 0,
          "discount": 500,
          "discountList": [
            {
              "couponId": 47831,
              "couponName": "buy more than $30 of whatever"
            }
          ],
          "total": 2000
        }
      ],
      "created_at": "2022-01-14T23:52:36.000Z",
      "updated_at": "2022-01-14T23:52:36.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK SalesHistoriesV1
401 Unauthorized Unauthorized Unauthorized

GET incoming_orders/{id}

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/incoming_orders/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/incoming_orders/{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", "/v1/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 = "/v1/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 /v1/incoming_orders/{id} \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/incoming_orders/{id}

Returns an incoming order by id

Parameters

Name In Type Required Description
id path integer(int32) true Incoming Order ID

Example responses

200 Response

{
  "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"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK IncomingOrders
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found None
422 Unprocessable Entity Invalid parameters None
500 Internal Server Error Internal Server Error None

POST incoming_orders

Code samples

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.post '/v1/incoming_orders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json; charset=utf-8'
}

r = requests.post('/v1/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; charset=utf-8"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/v1/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 = "/v1/incoming_orders";

      string json = @"{
  ""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
  }
}";
      IncomingOrdersRequest content = JsonConvert.DeserializeObject(json);
      await PostAsync(content, url);


    }

    /// Performs a POST Request
    public async Task PostAsync(IncomingOrdersRequest 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(IncomingOrdersRequest 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 /v1/incoming_orders \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=utf-8'

POST /v1/incoming_orders

Create a new incoming order

Body parameter

{
  "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
  }
}

Parameters

Name In Type Required Description
body body IncomingOrdersRequest true none

Example responses

200 Response

{
  "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"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK IncomingOrders
401 Unauthorized Unauthorized Unauthorized
422 Unprocessable Entity Invalid parameters None
500 Internal Server Error Internal Server Error None

GET info

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v1/info',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v1/info', 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", "/v1/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 = "/v1/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 /v1/info \
  -H 'Accept: application/json; charset=utf-8'

GET /v1/info

Returns venue information

Example responses

200 Response

{
  "code": 1,
  "region": "Oregon",
  "locale": "en-US",
  "vertical": "dispensaries",
  "name": "Oregon Top Shelf",
  "logo_thumb": "https://pbit-qa.s3.amazonaws.com/logos/Venue/thumb_3264_logo-ba531584ebfa69b2548e33d3e8b03c94.png",
  "logo_medium": "https://pbit-qa.s3.amazonaws.com/logos/Venue/medium_3264_logo-ba531584ebfa69b2548e33d3e8b03c94.png",
  "telephone": "5035551234",
  "address": "1234 Portland Street, Portland, OR",
  "street_address_line_1": "1234 Portland Street",
  "city": "Portland",
  "state": "OR",
  "zip_code": "97035",
  "country": "USA",
  "timezone": "Pacific Time (US & Canada)",
  "latitude": "44.0334",
  "longitude": "-123.092",
  "domains": [
    {
      "domain": "app.posabit.com"
    }
  ],
  "tax_rates": [
    {
      "id": 4324,
      "name": "Oregon Marijuana Tax",
      "rate": 1700,
      "tax_rate": "17.0",
      "price_included": true
    },
    {
      "id": 4325,
      "name": "Portland Marijuana Tax",
      "rate": 300,
      "tax_rate": "3.0",
      "price_included": true
    },
    {
      "id": 4398,
      "name": "Bag Tax",
      "rate": 0,
      "tax_rate": "0.0",
      "price_included": true
    }
  ],
  "payment_methods": [
    "Cash",
    "Debit Card",
    "Other"
  ],
  "venue_settings": {
    "online_order_curbside": "1",
    "online_order_delivery": "0"
  }
}

Responses

Status Meaning Description Schema
200 OK OK Info
401 Unauthorized Unauthorized Unauthorized
422 Unprocessable Entity Invalid parameters None
500 Internal Server Error Internal Server Error None

GET info v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/info',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/info \
  -H 'Accept: application/json'

GET /v2/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 '/v2/venue/customers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/customers \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 34,
  "current_page": 1,
  "total_pages": 34,
  "per_page": 1,
  "customers": [
    {
      "customer": {
        "id": 279160,
        "first_name": "Jane",
        "last_name": "Doe",
        "birth_year": null,
        "gender": "female",
        "telephone": "5551111111",
        "email": "test@gmail.com",
        "active": true,
        "sms_opt_out": false,
        "sms_opt_in": true,
        "signature": "",
        "address": "",
        "zipcode": "98033",
        "city": "",
        "state": "WA",
        "birthday": null,
        "customer_type": "medical",
        "terms_agreed": false,
        "points": 105
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK CustomersResponse
400 Bad Request Bad Request None
401 Unauthorized Unauthorized None
422 Unprocessable Entity Invalid Parameters None
500 Internal Server Error Internal Server Error None

POST customers

Code samples

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.post '/v2/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('/v2/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", "/v2/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 = "/v2/venue/customers";

      string json = @"{
  ""customer"": {
    ""first_name"": ""Test"",
    ""last_name"": ""User"",
    ""gender"": ""female"",
    ""telephone"": ""5551234567"",
    ""email"": ""test@posabit.com"",
    ""active"": 1,
    ""sms_opt_out"": 1,
    ""address"": ""123 water lane"",
    ""zipcode"": ""12345"",
    ""city"": ""Seattle"",
    ""state"": ""WA"",
    ""birthday"": ""01/01/1990"",
    ""terms_agreed"": 1,
    ""customer_type"": ""medical""
  }
}";
      CustomerRequest content = JsonConvert.DeserializeObject(json);
      await PostAsync(content, url);


    }

    /// Performs a POST Request
    public async Task PostAsync(CustomerRequest 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(CustomerRequest 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 /v2/venue/customers \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=utf-8'

POST /v2/venue/customers

Create a new customer

Body parameter

{
  "customer": {
    "first_name": "Test",
    "last_name": "User",
    "gender": "female",
    "telephone": "5551234567",
    "email": "test@posabit.com",
    "active": 1,
    "sms_opt_out": 1,
    "address": "123 water lane",
    "zipcode": "12345",
    "city": "Seattle",
    "state": "WA",
    "birthday": "01/01/1990",
    "terms_agreed": 1,
    "customer_type": "medical"
  }
}

Parameters

Name In Type Required Description
body body CustomerRequest true none

Example responses

200 Response

{
  "customer": {
    "id": 279160,
    "first_name": "Jane",
    "last_name": "Doe",
    "birth_year": null,
    "gender": "female",
    "telephone": "5551111111",
    "email": "test@gmail.com",
    "active": true,
    "sms_opt_out": false,
    "sms_opt_in": true,
    "signature": "",
    "address": "",
    "zipcode": "98033",
    "city": "",
    "state": "WA",
    "birthday": null,
    "customer_type": "medical",
    "terms_agreed": false,
    "points": 105
  }
}

Responses

Status Meaning Description Schema
200 OK OK Customer
204 No Content Record not found None
401 Unauthorized Unauthorized Unauthorized

GET customers/{id}

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/customers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/customers/{id} \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/venue/customers/{id}

Returns a customer by id

Parameters

Name In Type Required Description
id path integer(int32) true Customer ID

Example responses

200 Response

{
  "customer": {
    "id": 279160,
    "first_name": "Jane",
    "last_name": "Doe",
    "birth_year": null,
    "gender": "female",
    "telephone": "5551111111",
    "email": "test@gmail.com",
    "active": true,
    "sms_opt_out": false,
    "sms_opt_in": true,
    "signature": "",
    "address": "",
    "zipcode": "98033",
    "city": "",
    "state": "WA",
    "birthday": null,
    "customer_type": "medical",
    "terms_agreed": false,
    "points": 105
  }
}

Responses

Status Meaning Description Schema
200 OK OK Customer
400 Bad Request Bad Request None
401 Unauthorized Unauthorized Unauthorized
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 '/v2/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('/v2/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", "/v2/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 = "/v2/venue/customers/{id}";


      string json = @"{
  ""customer"": {
    ""points_adjustment"": ""150""
  }
}";
      CustomerPut content = JsonConvert.DeserializeObject(json);
      var result = await PutAsync(id, content, url);


    }

    /// Performs a PUT Request
    public async Task PutAsync(int id, CustomerPut 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(CustomerPut 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 /v2/venue/customers/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=utf-8'

PUT /v2/venue/customers/{id}

Update an existing customer

Body parameter

{
  "customer": {
    "points_adjustment": "150"
  }
}

Parameters

Name In Type Required Description
id path integer(int32) true Customer ID
body body CustomerPut true none

Example responses

200 Response

{
  "customer": {
    "id": 279160,
    "first_name": "Jane",
    "last_name": "Doe",
    "birth_year": null,
    "gender": "female",
    "telephone": "5551111111",
    "email": "test@gmail.com",
    "active": true,
    "sms_opt_out": false,
    "sms_opt_in": true,
    "signature": "",
    "address": "",
    "zipcode": "98033",
    "city": "",
    "state": "WA",
    "birthday": null,
    "customer_type": "medical",
    "terms_agreed": false,
    "points": 105
  }
}

Responses

Status Meaning Description Schema
200 OK OK Customer
204 No Content Record not found None
400 Bad Request Bad Request None
401 Unauthorized Unauthorized Unauthorized

GET customer_tags v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/customer_tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/customer_tags \
  -H 'Accept: application/json'

GET /v2/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 '/v2/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('/v2/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", "/v2/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 = "/v2/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 /v2/venue/customers/{id}/customer_tags/add \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /v2/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 '/v2/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('/v2/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", "/v2/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 = "/v2/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 /v2/venue/customers/{id}/customer_tags/remove \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

PUT /v2/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 v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/customer_queues',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/customer_queues \
  -H 'Accept: application/json'

GET /v2/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 '/v2/venue/coupons',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/coupons \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "code": 1,
  "total_records": 67,
  "current_page": 1,
  "total_pages": 67,
  "per_page": 1,
  "coupons": [
    {
      "id": 47667,
      "kind": "discount",
      "applies_to": "item",
      "auto_apply": true,
      "allow_stacking": true,
      "name": "Thirsty Thursday - 10% Off",
      "active": true,
      "points": "0",
      "redeemable_once": false,
      "manager_approve": false,
      "barcode": "460884203",
      "venue_id": 3264,
      "external_ref": null,
      "amount": 1000,
      "coupon_type": "percent",
      "rounding": "none",
      "expires_at": null,
      "starts_at": null,
      "image": {
        "url": "https://pbit-qa.s3.amazonaws.com/coupons/47667/barcode.png"
      },
      "background_image": {
        "url": "https://pbit-qa.s3.amazonaws.com/coupon_backgrounds/47667/background.png",
        "thumb": {
          "url": "https://pbit-qa.s3.amazonaws.com/coupon_backgrounds/47667/thumb_background.png"
        },
        "half_page": {
          "url": "https://pbit-qa.s3.amazonaws.com/coupon_backgrounds/47667/half_page_background.png"
        }
      },
      "payment_method_id": null,
      "payment_method_total": 0,
      "order_type": null,
      "order_source": "",
      "product_type_ids": [
        "",
        "4446"
      ],
      "product_ids": [
        ""
      ],
      "product_tag_ids": [
        ""
      ],
      "product_brand_ids": [
        ""
      ],
      "product_strain_ids": [
        ""
      ],
      "customer_tag_ids": [
        ""
      ],
      "manifest_item_ids": [
        ""
      ],
      "supplier_ids": [
        ""
      ],
      "venue_room_ids": [
        ""
      ],
      "one_item": false,
      "customer_type": "",
      "customer_level_ids": [
        ""
      ],
      "birthday": false,
      "product_weights": [
        ""
      ],
      "min_quantity": null,
      "min_amount": 0,
      "min_weight": "0.0",
      "min_weight_unit": null,
      "days": [
        "",
        "thu"
      ],
      "hours": null,
      "hour_start": "",
      "hour_end": "",
      "created_by": null,
      "created_at": "2019-10-21T15:55:35.000Z",
      "updated_at": "2021-01-25T19:53:14.000Z",
      "clicks": 1,
      "inventory_tier_ids": [
        ""
      ],
      "get_quantity": 1,
      "get_product_type_ids": [
        ""
      ],
      "get_product_ids": [
        ""
      ],
      "get_product_tag_ids": [
        ""
      ],
      "get_product_brand_ids": [
        ""
      ],
      "get_product_strain_ids": [
        ""
      ],
      "get_supplier_ids": null,
      "get_venue_room_ids": null,
      "get_manifest_item_ids": null,
      "get_product_weights": null,
      "get_inventory_tier_ids": null,
      "tier_weights": null,
      "profile_type": "any",
      "first_sale": false,
      "is_private": false,
      "external_redemption_failure_count": 0
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Coupons
401 Unauthorized Unauthorized Unauthorized

GET inventories

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/inventories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/inventories \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 1161,
  "current_page": 1,
  "total_pages": 1161,
  "per_page": 1,
  "inventory": [
    {
      "id": 210113,
      "product_id": 902429,
      "name": "Phat Panda - Lemon Danish Glaze",
      "unit": "280.0 gm",
      "price": 1300,
      "med_price": null,
      "last_price": 1300,
      "quantity_on_hand": "369.7",
      "sellable_quantity": "369.7",
      "ecomm_quantity": "369.7",
      "vendor": "PIONEER PRODUCTION AND PROCESSING",
      "vendor_license": null,
      "brand": "Phat Panda",
      "category": "Bulk Flower",
      "flower_type": "hybrid",
      "concentrate_type": null,
      "product_type": "hybrid",
      "product_family": "Flower",
      "description": "A perfect wake and bake strain. Sweet lemon and mell...",
      "image": [
        null
      ],
      "active": false,
      "bulk_item": true,
      "strain": "Lemon Danish",
      "thc_measure": "21.5%",
      "cbd_measure": "0.7%",
      "sku": "3264-902429",
      "discountable": true,
      "tier_name": "Top Shelf Tier",
      "created_at": "2019-10-16T20:37:49.000Z",
      "updated_at": "2022-07-05T17:31:23.000Z",
      "rooms": [
        {
          "Display Case 3": "369.7"
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK InventoriesResponse
401 Unauthorized Unauthorized Unauthorized

GET inventories/{id}

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/inventories/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/inventories/{id} \
  -H 'Accept: application/json'

GET /v2/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"
}

401 Response

{
  "message": "Invalid Token"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized Unauthorized
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 '/v2/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('/v2/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", "/v2/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 = "/v2/venue/inventories/{id}";


      string json = @"{
  ""inventory_sku"": {
    ""med_price"": 1100
  }
}";
      InventoryRequest content = JsonConvert.DeserializeObject(json);
      var result = await PutAsync(id, content, url);


    }

    /// Performs a PUT Request
    public async Task PutAsync(int id, InventoryRequest 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(InventoryRequest 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 /v2/venue/inventories/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json; charset=utf-8'

PUT /v2/venue/inventories/{id}

Update an inventory sku

Body parameter

{
  "inventory_sku": {
    "med_price": 1100
  }
}

Parameters

Name In Type Required Description
id path integer(int32) true Inventory Sku ID
body body InventoryRequest true none

Example responses

200 Response

{
  "id": 210113,
  "product_id": 902429,
  "name": "Phat Panda - Lemon Danish Glaze",
  "unit": "280.0 gm",
  "price": 1300,
  "med_price": null,
  "last_price": 1300,
  "quantity_on_hand": "369.7",
  "sellable_quantity": "369.7",
  "ecomm_quantity": "369.7",
  "vendor": "PIONEER PRODUCTION AND PROCESSING",
  "vendor_license": null,
  "brand": "Phat Panda",
  "category": "Bulk Flower",
  "flower_type": "hybrid",
  "concentrate_type": null,
  "product_type": "hybrid",
  "product_family": "Flower",
  "description": "A perfect wake and bake strain. Sweet lemon and mell...",
  "image": [
    null
  ],
  "active": false,
  "bulk_item": true,
  "strain": "Lemon Danish",
  "thc_measure": "21.5%",
  "cbd_measure": "0.7%",
  "sku": "3264-902429",
  "discountable": true,
  "tier_name": "Top Shelf Tier",
  "created_at": "2019-10-16T20:37:49.000Z",
  "updated_at": "2022-07-05T17:31:23.000Z",
  "rooms": [
    {
      "Display Case 3": "369.7"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Inventory
401 Unauthorized Unauthorized Unauthorized
404 Not Found Inventory not found None
422 Unprocessable Entity No valid attributes to update None

GET inventory_tiers

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/inventory_tiers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/inventory_tiers \
  -H 'Accept: application/json'

GET /v2/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; charset=utf-8'
}

result = RestClient.get '/v2/venue/inventory_transactions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/venue/inventory_transactions', 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", "/v2/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 = "/v2/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 /v2/venue/inventory_transactions \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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": 1,
  "current_page": 1,
  "total_pages": 1,
  "per_page": 1,
  "inventory_transactions": [
    {
      "id": 747285,
      "manifest_item_id": 276279,
      "sku_id": 214597,
      "transaction_type": "adjustment",
      "order_id": 25,
      "order_type": "Inventory::Audit",
      "quantity": "0.0",
      "reason": "entry_error",
      "updated_by": "Braden",
      "note": null,
      "cost_diff": 0,
      "created_at": "2022-02-08",
      "updated_at": "2022-02-08T00:07:18.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK InventoryTransactions
401 Unauthorized Unauthorized Unauthorized

GET manifests

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/manifests',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/manifests \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 46,
  "current_page": 1,
  "total_pages": 46,
  "per_page": 1,
  "manifests": [
    {
      "id": 364,
      "reference_no": "2",
      "supplier": "Oregon Top Shelf",
      "state": "accepted",
      "transfer_date": "2019-10-22",
      "delivery_time": null,
      "notes": "",
      "accepted_at": "2019-12-05T18:13:24.000Z",
      "accepted_by": "Matt McCullough",
      "received_cost": 10000,
      "accepted_cost": null,
      "received_quantity": 100,
      "accepted_quantity": null,
      "has_marijuana": true,
      "import_source": null,
      "discount": null,
      "manifest_items": [
        {
          "id": 276454,
          "manifest_id": 364,
          "state": "active",
          "supplier_quantity": "100.0",
          "accepted_quantity": "100.0",
          "quantity_on_hand": "5.0",
          "pre_return_quantity": null,
          "cost_per_unit": 100,
          "inventory_id": 214643,
          "lot_number": "1A4FFFB0007A122000003899",
          "barcode": "1A4FFFB0007A122000003899",
          "batch_number": "ncx7pmo24XXNGt0H",
          "last_audit": null,
          "venue_room": "Display Case 1",
          "harvest_date": null,
          "thc_measure": "70.0%",
          "cbd_measure": "0.0%",
          "coa_url": null,
          "created_at": "2019-10-22T00:18:31.000Z",
          "updated_at": "2020-05-04T20:21:26.000Z"
        }
      ],
      "created_at": "2019-10-22T00:18:31.000Z",
      "updated_at": "2019-12-05T18:13:24.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Manifests
401 Unauthorized Unauthorized Unauthorized

GET manifest_items

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/manifest_items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/manifest_items \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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"
    }
  ]
}

401 Response

{
  "message": "Invalid Token"
}

Responses

Status Meaning Description Schema
200 OK OK ManifestItems
401 Unauthorized Unauthorized Unauthorized

GET menu_feeds v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/menu_feeds/{feed_key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/menu_feeds/{feed_key}', 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", "/v2/menu_feeds/{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 = "/v2/menu_feeds/{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 /v2/menu_feeds/{feed_key} \
  -H 'Accept: application/json'

GET /v2/menu_feeds/{feed_key}

Parameters

Name In Type Required Description
feed_key path string true none

Example responses

200 Response

{
  "menu_feed": {
    "title": "Test Menu Feed",
    "feed_key": "aebbfb2a-27a2-4d96-a357-94d23794215e",
    "description": "",
    "feed_type": "posabit menu",
    "menu_groups": [
      {
        "name": "Flower",
        "category_guid": "Tlzs2pMnHzR47C5OIUwC7w",
        "name_template": "name",
        "combine_weights": true,
        "description": "",
        "image": {
          "is_default": true,
          "og": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "lg": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "md": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
          "sm": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png"
        },
        "menu_items": [
          {
            "id": "(C) Gorilla Glue - Phat Panda - Flower",
            "guid": "104e4ca0-d909-468d-8623-9ad184602590",
            "name": "Sour Super Haze Alien Fruity Pebble",
            "description": "Gets you high.",
            "is_medical_only": false,
            "tag_list": [
              "Sale Day",
              "Item Box Test"
            ],
            "flower_type": "sativa",
            "brand": "Phat Panda",
            "strain": "(C) Gorilla Glue",
            "terpenes": [
              "Caryophyllene"
            ],
            "effects": [],
            "flavors": [],
            "product_type": "Flower",
            "is_marijuana": true,
            "tier_name": "Test tier ",
            "brand_logo": {
              "is_default": true,
              "og": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "lg": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "md": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png",
              "sm": "https://dlaatut4pkbv4.cloudfront.net/assets/missing_image.png"
            },
            "product_image": {
              "is_default": false,
              "is_product_specific_image": false,
              "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
              "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "sm": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
              "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
            },
            "product_image_v2": {
              "is_default": false,
              "is_product_specific_image": false,
              "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
              "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/large_image.jpg",
              "sm": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
              "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
            },
            "images": [
              {
                "name": "Flower",
                "og": "https://pbit-staging.s3.amazonaws.com/images/image/2307/image.jpg",
                "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2307/web_image.jpg",
                "md": "https://pbit-staging.s3.amazonaws.com/images/image/2307/medium_image.jpg",
                "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2307/thumb_image.jpg"
              },
              {
                "name": "flower 2.png",
                "og": "https://pbit-staging.s3.amazonaws.com/images/image/2611/flower_2.png",
                "lg": "https://pbit-staging.s3.amazonaws.com/images/image/2611/web_flower_2.png",
                "md": "https://pbit-staging.s3.amazonaws.com/images/image/2611/medium_flower_2.png",
                "thumb": "https://pbit-staging.s3.amazonaws.com/images/image/2611/thumb_flower_2.png"
              }
            ],
            "prices": [
              {
                "id": "855277_Test tier _1g",
                "name": "Sour Super Haze Alien Fruity Pebble",
                "price_cents": 1500,
                "med_price_cents": null,
                "unit": "1.0",
                "unit_type": "grams",
                "quantity_on_hand": "4952.0",
                "equivalent_weight": null,
                "equivalent_unit": null,
                "supplier": "POSaBIT Producer/Processor"
              }
            ],
            "thc": {
              "current": "20.0",
              "low": "20.0",
              "high": "20.0",
              "unit_type": "%"
            },
            "cbd": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "thca": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "cbda": {
              "current": "0.0",
              "low": "0.0",
              "high": "0.0",
              "unit_type": "%"
            },
            "total_thc": {
              "current": 20,
              "low": 20,
              "high": 20,
              "unit_type": "%"
            }
          }
        ]
      }
    ]
  }
}

404 Response

{
  "error": "Could not find menu feed"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
404 Not Found Not Found Inline

Response Schema

GET product_brands

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/product_brands',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/product_brands \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 297,
  "current_page": 1,
  "total_pages": 297,
  "per_page": 1,
  "product_brands": [
    {
      "id": 8222,
      "merchant_id": 7705,
      "name": "High Five Farms",
      "abbreviation": null,
      "image": {
        "url": null,
        "large": {
          "url": null
        },
        "medium": {
          "url": null
        },
        "small": {
          "url": null
        },
        "thumb": {
          "url": null
        }
      },
      "created_at": "2019-10-16T20:37:49.000Z",
      "updated_at": "2019-10-16T20:37:49.000Z",
      "imported_from": "file",
      "curated_brand_id": null
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK ProductBrands
401 Unauthorized Unauthorized Unauthorized

GET product_tags v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/product_tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/product_tags \
  -H 'Accept: application/json'

GET /v2/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 v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/product_types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/product_types \
  -H 'Accept: application/json'

GET /v2/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": 14
    }
  ]
}

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 '/v2/venue/product_strains',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/product_strains \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 532,
  "current_page": 1,
  "total_pages": 532,
  "per_page": 1,
  "product_strains": [
    {
      "id": 32041,
      "merchant_id": 7705,
      "name": "Ghost Train Haze",
      "created_at": "2019-10-16T20:37:49.000Z",
      "updated_at": "2019-10-16T20:37:49.000Z",
      "imported_from": "file"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK ProductStrains
401 Unauthorized Unauthorized Unauthorized

GET return_manifests

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/return_manifests',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/return_manifests \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 19,
  "current_page": 1,
  "total_pages": 19,
  "per_page": 1,
  "manifests": [
    {
      "id": 212,
      "reference_no": "WARPOSABIT.ITDXB",
      "supplier": null,
      "state": "transferred_out",
      "transfer_date": null,
      "delivery_time": null,
      "notes": "",
      "return_destination_name": "POSaBIT Producer/Processor",
      "return_destination_license": "",
      "transferred_at": "2018-11-01T19:06:00.000Z",
      "manifest_items": [
        {
          "id": 177925,
          "manifest_id": null,
          "state": "transferred_out",
          "supplier_quantity": "0.0",
          "accepted_quantity": "0.0",
          "quantity_on_hand": "0.0",
          "pre_return_quantity": "1.0",
          "cost_per_unit": 100,
          "inventory_id": 108726,
          "lot_number": "WARPOSABIT.IN24YD",
          "barcode": "WAJPOSABIT.IN1LOX",
          "batch_number": "WARPOSABIT.BA3BJV",
          "last_audit": null,
          "venue_room": "Drawer #1",
          "harvest_date": null,
          "thc_measure": "0.0%",
          "cbd_measure": "0.0%",
          "coa_url": null,
          "created_at": "2018-08-28T20:30:16.000Z",
          "updated_at": "2018-12-18T17:52:37.000Z"
        }
      ],
      "created_at": "2018-08-28T20:33:40.000Z",
      "updated_at": "2018-11-01T19:06:30.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK ReturnManifests
401 Unauthorized Unauthorized Unauthorized

GET venue_rooms v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/v2/venue/venue_rooms',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/venue_rooms \
  -H 'Accept: application/json'

GET /v2/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 '/v2/venue/sales_histories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/sales_histories \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 36,
  "current_page": 1,
  "total_pages": 36,
  "per_page": 1,
  "sales_histories": [
    {
      "id": 49053313,
      "is_medical": false,
      "ordered_at": "2022-06-14T19:37:28.000Z",
      "ordered_at_local": "2022-06-14T12:37:28.000-07:00",
      "sale_type": "sale",
      "order_source": "walk_in",
      "terminal_till_id": 4676,
      "local_order_id": "3264-3-8881-123727",
      "customer_id": 544773,
      "user_id": 12777,
      "sub_total": 1127,
      "discount": 260,
      "tax": 173,
      "total": 1040,
      "cost": 275,
      "items": [
        {
          "item_id": 91312852,
          "sales_history_id": 49053313,
          "product_id": 902427,
          "inventory_id": 210111,
          "lot_id": 261876,
          "lot_number": "WAR414871.IN5SAJM",
          "is_marijuana": true,
          "quantity": 1,
          "weight": "1.0",
          "cost": 275,
          "sub_total": 1127,
          "tax": 173,
          "discount": 260,
          "sku": "WAJ416746.IN5NZ29",
          "category": "Bulk Flower",
          "brand": "High Five Farms",
          "product_name": "High Five Farms - Ghost Train Haze",
          "family_name": "Flower",
          "unit_of_weight": "gm",
          "tier_name": "Top Shelf Tier",
          "discount_list": [
            {
              "coupon_id": 47769,
              "coupon_name": "test happy hour"
            }
          ],
          "total": 1040
        }
      ],
      "sales_tenders": [
        {
          "sales_tender_id": 11738303,
          "subtotal": 867,
          "tax": 173,
          "total": 1040,
          "payment_method_name": "Cash"
        }
      ],
      "created_at": "2022-06-14T19:37:30.000Z",
      "updated_at": "2022-06-14T19:37:30.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK SalesHistories
401 Unauthorized Unauthorized Unauthorized

GET sales_histories/{id} v2

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '/api/v2/venue/sales_histories/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('/api/v2/venue/sales_histories/{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", "/api/v2/venue/sales_histories/{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 = "/api/v2/venue/sales_histories/{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 /api/v2/venue/sales_histories/{id} \
  -H 'Accept: application/json'

GET /api/v2/venue/sales_histories/{id}

Update an existing customer

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "sales_history": {
    "id": 49054557,
    "is_medical": false,
    "ordered_at": "2024-08-02T18:42:21.000Z",
    "ordered_at_local": "2024-08-02T18:42:21.000Z",
    "sale_type": "sale",
    "order_source": "walk_in",
    "terminal_till_id": 5906,
    "terminal_id": 8829,
    "local_order_id": "3221-169-8082-114218",
    "customer_id": 187408,
    "user_id": 12794,
    "sub_total": 8063,
    "discount": 4130,
    "tax": 722,
    "total": 4655,
    "cost": 764,
    "status": "COMPLETE",
    "items": [
      {
        "item_id": 91315881,
        "sales_history_id": 49054557,
        "product_id": 1031454,
        "inventory_id": 334814,
        "lot_id": 560579,
        "lot_number": "COAIQRT-20240613-001",
        "is_marijuana": true,
        "quantity": 1,
        "weight": "1.0",
        "unit_weight": "3.5",
        "unit_of_weight": "grams",
        "weight_in_grams": "3.5",
        "cost": 700,
        "sub_total": 1377,
        "tax": 123,
        "discount": 705,
        "sku": "COAIQRT-20240613-001",
        "category": "Flower",
        "brand": "Global Xtracts",
        "product_name": "The Finest Green",
        "family_name": "Flower",
        "tier_name": null,
        "discount_list": [
          {
            "coupon_id": 47626,
            "coupon_name": "Will's Test Employee Discount"
          },
          {
            "coupon_id": 47541,
            "coupon_name": "ZZ - Friends & Family 30% Off (Trove Extended)"
          },
          {
            "coupon_id": 47601,
            "coupon_name": "Tribal Tag Test"
          }
        ],
        "total": 795
      },
      {
        "item_id": 91315882,
        "sales_history_id": 49054557,
        "product_id": 801385,
        "inventory_id": 108709,
        "lot_id": 222607,
        "lot_number": "WARPOSABIT.IN33TB",
        "is_marijuana": true,
        "quantity": 1,
        "weight": "1.0",
        "unit_weight": "3.5",
        "unit_of_weight": "grams",
        "weight_in_grams": "3.5",
        "cost": 64,
        "sub_total": 6686,
        "tax": 599,
        "discount": 3425,
        "sku": "WAJPOSABIT.IN1LOY",
        "category": "Flower",
        "brand": null,
        "product_name": "Alta Nova - Blue Hawaiian (3.5g)",
        "family_name": "Flower",
        "tier_name": null,
        "discount_list": [
          {
            "coupon_id": 47626,
            "coupon_name": "Will's Test Employee Discount"
          },
          {
            "coupon_id": 47541,
            "coupon_name": "ZZ - Friends & Family 30% Off (Trove Extended)"
          },
          {
            "coupon_id": 47601,
            "coupon_name": "Tribal Tag Test"
          }
        ],
        "total": 3860
      }
    ],
    "sales_tenders": [
      {
        "sales_tender_id": 11739651,
        "subtotal": 3933,
        "tax": 722,
        "total": 4655,
        "payment_method_name": "Cash"
      }
    ],
    "created_at": "2024-08-02T18:43:01.000Z",
    "updated_at": "2024-08-02T18:43:01.000Z"
  }
}

Responses

Status Meaning Description Schema
200 OK OK Inline

Response Schema

Response Headers

Status Header Type Format Description
200 X-Frame-Options string none
200 X-XSS-Protection integer none
200 X-Content-Type-Options string none
200 X-Permitted-Cross-Domain-Policies string none
200 Referrer-Policy string none
200 Content-Type string none
200 Access-Control-Allow-Origin string none
200 Access-Control-Allow-Methods string none
200 Access-Control-Allow-Headers string none
200 Access-Control-Max-Age integer none
200 ETag string none
200 Cache-Control string none
200 Content-Security-Policy string none
200 X-Request-Id string none
200 X-Runtime number none
200 vary string none
200 Content-Length integer none

GET suppliers

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/suppliers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/suppliers \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 104,
  "current_page": 1,
  "total_pages": 104,
  "per_page": 1,
  "suppliers": [
    {
      "id": 123456,
      "merchant_id": 1111,
      "name": "POSaBIT Farms",
      "license_number": "12345",
      "telephone_number": "5551234567",
      "email": "",
      "address": "123 Test Ln",
      "city": "Seattle",
      "state": "WA",
      "zipcode": "12345",
      "country": "US",
      "notes": "",
      "created_at": "2022-02-14T04:08:30.000Z",
      "updated_at": "2022-03-31T18:56:49.000Z",
      "deactivated": false,
      "manifest_freq_in_days": 13,
      "lead_time": 2,
      "velocity_days": 30,
      "manifests_count": 4,
      "last_adj_levels": null
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Suppliers
401 Unauthorized Unauthorized Unauthorized

GET terminal_tills

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/terminal_tills',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/terminal_tills \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 1408,
  "current_page": 1,
  "total_pages": 1408,
  "per_page": 1,
  "terminal_tills": [
    {
      "id": 1673,
      "terminal_id": 8216,
      "state": "pending",
      "till_ref": "326411571689226811",
      "start_time": "2019-10-21T20:20:26.000Z",
      "end_time": "2019-10-21T22:11:54.000Z",
      "start_amount": 20000,
      "end_amount": 0,
      "left_in_drawer": 0,
      "notes": "",
      "opened_by": "Andy Sweet",
      "closed_by": "Andy Sweet",
      "created_at": "2019-10-21T20:20:27.000Z",
      "updated_at": "2019-10-21T22:11:55.000Z",
      "adjustments": []
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK TerminalTills
401 Unauthorized Unauthorized Unauthorized

GET transfer_manifests

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/transfer_manifests',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/transfer_manifests \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 1,
  "current_page": 1,
  "total_pages": 1,
  "per_page": 1,
  "manifests": [
    {
      "id": 207,
      "reference_no": "12345",
      "supplier": null,
      "state": "transferred_out",
      "transfer_date": null,
      "delivery_time": null,
      "notes": "",
      "return_destination_name": "Oregon Top Shelf 2",
      "return_destination_license": "050-X0002",
      "transferred_at": "2020-11-19T20:46:42.000Z",
      "manifest_items": [
        {
          "id": 276458,
          "manifest_id": null,
          "state": "transferred_out",
          "supplier_quantity": "1987.0",
          "accepted_quantity": "1987.0",
          "quantity_on_hand": "0.0",
          "pre_return_quantity": "199.65",
          "cost_per_unit": 225,
          "inventory_id": 214766,
          "lot_number": "PB863700010207B",
          "barcode": "PB863700010906B",
          "batch_number": null,
          "last_audit": null,
          "venue_room": "Back Room",
          "harvest_date": null,
          "thc_measure": "21.7%",
          "cbd_measure": "0.4%",
          "coa_url": null,
          "created_at": "2019-10-22T16:16:27.000Z",
          "updated_at": "2021-03-23T21:45:57.000Z"
        }
      ],
      "created_at": "2020-11-17T20:46:42.000Z",
      "updated_at": "2020-11-19T20:46:42.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK TransferManifests
401 Unauthorized Unauthorized Unauthorized

GET users

Code samples

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json; charset=utf-8'
}

result = RestClient.get '/v2/venue/users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json; charset=utf-8'
}

r = requests.get('/v2/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", "/v2/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 = "/v2/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 /v2/venue/users \
  -H 'Accept: application/json; charset=utf-8'

GET /v2/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

200 Response

{
  "total_records": 10,
  "current_page": 1,
  "total_pages": 10,
  "per_page": 1,
  "users": [
    {
      "id": 12926,
      "first_name": "Budtender 2",
      "last_name": "Budtender 2",
      "perm_level": "none",
      "access_level": "cashier",
      "email": "budtender2@posabit.com",
      "created_at": "2019-11-08T00:54:36.000Z",
      "updated_at": "2021-04-19T21:25:19.000Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK Users
401 Unauthorized Unauthorized Unauthorized

Schemas

CustomerResponseV1

{
  "total_records": 475,
  "current_page": 1,
  "total_pages": 475,
  "per_page": 1,
  "customers": [
    {
      "customerId": 279159,
      "firstName": "JANE",
      "created_at": "2019-10-21T20:21:19.000Z",
      "updated_at": "2021-10-05T19:31:24.000Z",
      "birthyear": 1992,
      "gender": "female",
      "phone": "5551111111"
    }
  ]
}

/v1/venue/customers Response

Properties

Name Type Required Restrictions Description
total_records integer(int32) true none Total number of customers in a venue
current_page integer(int32) true none Current page of results
total_pages integer(int32) true none Total number of pages for results
per_page integer(int32) true none Number of results per page
customers array true none Customer description
» customerId integer(int32) false none Customer ID
» firstName string false none Customer first name
» created_at string false none Customer created at datetime
» updated_at string false none Customer updated at datetime
» birthyear string¦null false none Customer birth year
» gender string false none Customer gender
» phone string false none Customer phone number

EmployeeResponse

{
  "total_records": 1,
  "current_page": 1,
  "total_pages": 1,
  "per_page": 1,
  "employees": [
    {
      "employeeId": 12998,
      "firstName": "Jane",
      "created_at": "2022-04-21T22:41:04.000Z",
      "updated_at": "2022-04-21T22:41:04.000Z"
    }
  ]
}

/v1/venue/employees Response

Properties

Name Type Required Restrictions Description
total_records integer(int32) true none Total number of employees in a venue
current_page integer(int32) true none Current page of results
total_pages integer(int32) true none Total number of pages for results
per_page integer(int32) true none Number of results per page
employees array true none Employee description
» employeeId integer(int32) false none Employee ID
» firstName string false none Employee first name
» created_at string false none Employee created at datetime
» updated_at string false none Employee updated at datetime

InventoriesResponseV1

{
  "total_records": 1182,
  "current_page":