Printavo API

https://printavo.docs.apiary.io
Admin
The Printavo API is a JSON-based interface used to access information within a Printavo account,...
Tokens:729,900
Snippets:4,193
Trust Score:9.9
Update:11 months ago
Show doc for...
Tokens:
Raw
### Fetch Expense Details - Go Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using Go. This snippet demonstrates making an HTTP GET request using the standard 'net/http' package.

```Go
package main

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

func main() {
	url := "https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233"

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Printf("Error creating request: %s\n", err)
		return
	}
	req.Header.Set("Accept", "application/json")

	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		fmt.Printf("Error sending request: %s\n", err)
		return
	}
	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %s\n", err)
		return
	}

	fmt.Println(string(body))
}
```

--------------------------------

### Get Delivery Method Details (Go)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using Go. This snippet demonstrates making an HTTP GET request using Go's standard library packages.

```go
// Go code example for fetching delivery method details would go here.
// This would use the 'net/http' package.
```

--------------------------------

### Product Show API Call Example (cURL, Java, JavaScript, Node.js, Python, PHP, Ruby, Go, C#, Visual Basic, Groovy, Objective-C, Swift)

Source: https://printavo.docs.apiary.io/reference/products/product/product-show

Demonstrates how to fetch details for a specific product using the Printavo API. This snippet includes examples for making the GET request in various programming languages. It requires product ID, API version, and authentication credentials (email and token) as parameters.

```cURL
curl -X GET "https://www.printavo.com/api/v1/products/id?email=test%40example.com&token=1dofnewoi233"
```

```Java
// Java example not provided in the source text.
```

```JavaScript
// JavaScript example not provided in the source text.
```

```Node.js
// Node.js example not provided in the source text.
```

```Python
// Python example not provided in the source text.
```

```PHP
// PHP example not provided in the source text.
```

```Ruby
// Ruby example not provided in the source text.
```

```Go
// Go example not provided in the source text.
```

```C#
// C# example not provided in the source text.
```

```Visual Basic
// Visual Basic example not provided in the source text.
```

```Groovy
// Groovy example not provided in the source text.
```

```Objective-C
// Objective-C example not provided in the source text.
```

```Swift
// Swift example not provided in the source text.
```

--------------------------------

### Fetch Expense Details - Groovy Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using Groovy. This snippet demonstrates using the 'HTTPBuilder' library for making HTTP GET requests.

```Groovy
@Grab('org.codehaus.groovy.modules.http-builder:http-builder:0.7.1')
import groovy.json.JsonSlurper
import groovyx.net.http.*

def http = new HTTPBuilder('https://www.printavo.com')
http.auth.basic 'test@example.com', '1dofnewoi233'

http.get(
    path: '/api/v1/expenses/27183',
    contentType: ContentType.JSON,
    accept: ContentType.JSON,
    success: {
        resp, json -> println "Success: ${json}"
    },
    failure: {
        resp, err -> println "Failure: ${err}"
    }
)
```

--------------------------------

### Customers Index - C# Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

C# example for fetching customer data. This would typically use the 'HttpClient' class from the .NET framework to send an HTTP GET request.

```C#
// C# example using HttpClient:
// using System.Net.Http;
// using System.Threading.Tasks;
// 
// public class CustomerApiClient
// {
//     public async Task<string> GetCustomersAsync()
//     {
//         using (HttpClient client = new HttpClient())
//         {
//             string url = "https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false";
//             HttpResponseMessage response = await client.GetAsync(url);
//             response.EnsureSuccessStatusCode(); // Throw if not successful
//             return await response.Content.ReadAsStringAsync();
//         }
//     }
// }
```

--------------------------------

### Customers Index - Go Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

Example of retrieving customers using Go. This snippet would utilize Go's standard 'net/http' package to make the GET request to the Printavo API.

```Go
// Go example using net/http:
// package main
// 
// import (
// 	"fmt"
// 	"io/ioutil"
// 	"net/http"
// )
// 
// func main() {
// 	url := "https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false"
// 	resp, err := http.Get(url)
// 	if err != nil {
// 		fmt.Println("Error making request:", err)
// 		return
// 	}
// 	defer resp.Body.Close()
// 	body, err := ioutil.ReadAll(resp.Body)
// 	if err != nil {
// 		fmt.Println("Error reading response body:", err)
// 		return
// 	}
// 	fmt.Println(string(body))
// }
```

--------------------------------

### Fetch Expense Details - C# Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using C#. This snippet uses the 'HttpClient' class for making HTTP GET requests.

```C#
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ExpenseFetcher
{
    public static async Task FetchExpenseAsync()
    {
        string url = "https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233";
        
        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
            
            try
            {
                HttpResponseMessage response = await client.GetAsync(url);
                response.EnsureSuccessStatusCode(); // Throw an exception if the status code is not a success
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine(responseBody);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Request error: {e.Message}");
            }
        }
    }

    public static void Main(string[] args)
    {
        FetchExpenseAsync().Wait();
    }
}
```

--------------------------------

### Task Show API Call Examples

Source: https://printavo.docs.apiary.io/reference/tasks/task/tasks-show

Examples for fetching a specific task using the Printavo API. Includes cURL and multiple programming language examples. Requires version, id, email, and token as parameters.

```cURL
curl "https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233"
```

```JavaScript
fetch("https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233")
  .then(response => response.json())
  .then(data => console.log(data));
```

```Python
import requests

url = "https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233"
response = requests.get(url)
print(response.json())
```

```PHP
<?php
$url = "https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233";
$response = file_get_contents($url);
$data = json_decode($response, true);
print_r($data);
?>
```

```Ruby
require 'net/http'
require 'uri'

uri = URI.parse("https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233")
response = Net::HTTP.get_response(uri)
puts JSON.parse(response.body)
```

```Go
package main

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

func main() {
	resp, err := http.Get("https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(body))
}
```

```Java
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class TaskShow {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233"))
                .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
```

```Node.js
const https = require('https');

https.get('https://www.printavo.com/api/v1/tasks/id?email=test%40example.com&token=1dofnewoi233', (resp) => {
  let data = '';
  resp.on('data', (chunk) => {
    data += chunk;
  });
  resp.on('end', () => {
    console.log(JSON.parse(data));
  });
}).on('error', (err) => {
  console.log('Error: ' + err.message);
});
```

--------------------------------

### Get Delivery Method Details (C#)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using C#. This snippet shows how to make an HTTP GET request using .NET's HttpClient class.

```csharp
// C# code example for fetching delivery method details would go here.
// This would use the System.Net.Http.HttpClient class.
```

--------------------------------

### Get Delivery Method Details (Swift)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using Swift. This snippet demonstrates making an HTTP GET request using URLSession.

```swift
// Swift code example for fetching delivery method details would go here.
// This would use the URLSession class.
```

--------------------------------

### Get Delivery Method Details (Visual Basic)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using Visual Basic. This snippet demonstrates making an HTTP GET request using .NET's HttpClient class.

```vbnet
' Visual Basic code example for fetching delivery method details would go here.
' This would use the System.Net.Http.HttpClient class.
```

--------------------------------

### Products Index API Request Examples

Source: https://printavo.docs.apiary.io/reference/products/products-collection/product-index

Examples of how to call the Products Index API endpoint. This endpoint retrieves a list of products, supporting pagination. It requires API version, email, and token as parameters.

```cURL
curl "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20"
```

```Java
String url = "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20";
// Use Java's http client to make the request.
```

```JavaScript
fetch('https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20')
  .then(response => response.json())
  .then(data => console.log(data));
```

```Node.js
const axios = require('axios');

axios.get('https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20')
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });
```

```Perl
use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $response = $ua->get('https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20');

if ($response->is_success) {
    print $response->decoded_content;
} else {
    print $response->status_line;
}
```

```Python
import requests

url = "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20"
response = requests.get(url)

print(response.json())
```

```PHP
<?php
$url = 'https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20';
$response = file_get_contents($url);

$data = json_decode($response, true);
print_r($data);
?>
```

```Ruby
require 'httparty'

url = 'https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20'
response = HTTParty.get(url)

puts response.parsed_response
```

```Go
package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	url := "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20"
	resp, err := http.Get(url)
	if err != nil {
		fmt.Println("Error making request:", err)
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading response body:", err)
		return
	}

	var data map[string]interface{}
	if err := json.Unmarshal(body, &data); err != nil {
		fmt.Println("Error unmarshalling JSON:", err)
		return
	}

	fmt.Println(data)
}
```

```C#
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ApiClient
{
    public static async Task GetProductsAsync()
    {
        using (HttpClient client = new HttpClient())
        {
            string url = "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20";
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode(); // Throw if HTTP status code is not 2xx
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
    }
}
```

```Visual Basic
Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

Public Class ApiClient
    Public Shared Async Function GetProductsAsync() As Task
        Using client As New HttpClient()
            Dim url As String = "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20"
            Dim response As HttpResponseMessage = Await client.GetAsync(url)
            response.EnsureSuccessStatusCode()
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Console.WriteLine(responseBody)
        End Using
    End Function
End Class
```

```Groovy
import groovy.json.JsonSlurper

def url = "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20"
def response = new URL(url).getText()

def data = new JsonSlurper().parseText(response)
println data
```

```Objective-C
#import <Foundation/Foundation.h>

// Use NSURLSession to make the request
// Example implementation would involve creating an NSURLSession, NSURLRequest, and an NSURLSessionDataTask.
```

```Swift
import Foundation

let url = URL(string: "https://www.printavo.com/api/v1/products?email=test%40example.com&token=1dofnewoi233&page=1&per_page=20")

let task = URLSession.shared.dataTask(with: url!) { data, response, error in
    if let data = data {
        // Process the data, e.g., decode JSON
        print(String(data: data, encoding: .utf8)!)
    } else if let error = error {
        print("Error: \(error)")
    }
}
task.resume()
```

--------------------------------

### Customers Index - Swift Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

Swift code example for fetching customer data. This uses the URLSession API to make an asynchronous HTTP GET request to the Printavo API.

```Swift
// Swift example using URLSession:
// import Foundation
// 
// func fetchCustomers() {
//     guard let url = URL(string: "https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false") else { return }
// 
//     URLSession.shared.dataTask(with: url) { data, response, error in
//         if let error = error {
//             print("Error: \(error.localizedDescription)")
//         } else if let data = data {
//             if let jsonString = String(data: data, encoding: .utf8) {
//                 print("Response: \(jsonString)")
//             }
//         }
//     }.resume()
// }
// 
// fetchCustomers()
```

--------------------------------

### Customers Index - Ruby Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

Shows how to fetch customers using Ruby, commonly with the built-in 'net/http' library or gems like 'httparty'. This code sends an HTTP GET request and handles the response.

```Ruby
# Ruby example using Net::HTTP:
# require 'net/http'
# require 'uri'
# 
# uri = URI.parse('https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false')
# http = Net::HTTP.new(uri.host, uri.port)
# http.use_ssl = true
# 
# request = Net::HTTP::Get.new(uri.request_uri)
# response = http.request(request)
# 
# puts response.body
```

--------------------------------

### Get Delivery Method Details (Groovy)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using Groovy. This snippet demonstrates making an HTTP GET request, potentially using libraries like Apache HttpClient.

```groovy
// Groovy code example for fetching delivery method details would go here.
// This might use Groovy's HTTPBuilder or Java's HttpClient.
```

--------------------------------

### Customers Index - Node.js Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

Provides a Node.js example for retrieving customers. This typically uses libraries like 'axios' or the built-in 'http' module to make the GET request to the Printavo API.

```JavaScript
// Node.js example using axios:
// const axios = require('axios');
// const url = 'https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false';
// axios.get(url)
//   .then(response => {
//     console.log(response.data);
//   })
//   .catch(error => {
//     console.error('Error:', error);
//   });
```

--------------------------------

### Fetch Expenses - cURL Example

Source: https://printavo.docs.apiary.io/reference/expenses/expenses-collection/expenses-index

Example of how to fetch expenses using cURL. This command-line tool allows for making HTTP requests to the Printavo API, demonstrating the GET request with necessary parameters.

```bash
curl -X GET "https://www.printavo.com/api/v1/expenses?email=test@example.com&token=1dofnewoi233&page=1&per_page=20"
```

--------------------------------

### Get Delivery Method Details (PHP)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using PHP. This snippet demonstrates making an HTTP GET request, likely using cURL or stream contexts.

```php
// PHP code example for fetching delivery method details would go here.
// This could use cURL functions or file_get_contents with stream contexts.
```

--------------------------------

### Get Delivery Method Details (Ruby)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-method/delivery-method-show

Example of fetching delivery method details using Ruby. This snippet shows how to make an HTTP GET request to the API, typically using the 'net/http' library.

```ruby
# Ruby code example for fetching delivery method details would go here.
# This would use the Net::HTTP module.
```

--------------------------------

### Create Task API Request Examples

Source: https://printavo.docs.apiary.io/reference/tasks/tasks-collection/tasks-create

Examples for creating a task via the API. This endpoint allows for detailed task creation with various filtering parameters. It supports multiple programming languages for integration.

```cURL
curl -X POST https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before= \
-H "Content-Type: application/json" \
-H "Accept-Charset: utf-8" \
-H "Connection: keep-alive" \
-d '{
  "formatted_due_date": "11/11/2014",
  "task_name": "testing task",
  "taskable_type": "Order",
  "taskable_id": 123
}'
```

```JavaScript
const options = {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Accept-Charset': 'utf-8',
    'Connection': 'keep-alive'
  },
  body: JSON.stringify({
    formatted_due_date: "11/11/2014",
    task_name: "testing task",
    taskable_type: "Order",
    taskable_id: 123
  })
};

fetch('https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(error => console.error('Error:', error));
```

```Node.js
const https = require('https');

const data = JSON.stringify({
  formatted_due_date: "11/11/2014",
  task_name: "testing task",
  taskable_type: "Order",
  taskable_id: 123
});

const options = {
  hostname: 'www.printavo.com',
  port: 443,
  path: '/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length
  }
};

const req = https.request(options, (res) => {
  let responseBody = '';
  res.on('data', (chunk) => {
    responseBody += chunk;
  });
  res.on('end', () => {
    console.log(JSON.parse(responseBody));
  });
});

req.on('error', (error) => {
  console.error('Error:', error);
});

req.write(data);
req.end();
```

```Python
import requests
import json

url = "https://www.printavo.com/api/version/tasks"
params = {
    "email": "test@example.com",
    "token": "1dofnewoi233",
    "page": 1,
    "per_page": 25,
    "completed": "",
    "assigned_user_id": "",
    "included_orderstatus_ids": "",
    "taskable_type": "",
    "taskable_id": "",
    "due_after": "",
    "due_before": ""
}
data = {
    "formatted_due_date": "11/11/2014",
    "task_name": "testing task",
    "taskable_type": "Order",
    "taskable_id": 123
}

headers = {
    "Content-Type": "application/json",
    "Accept-Charset": "utf-8",
    "Connection": "keep-alive"
}

response = requests.post(url, params=params, data=json.dumps(data), headers=headers)

print(response.json())
```

```PHP
<?php

$url = 'https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=';

$data = json_encode([
    'formatted_due_date' => '11/11/2014',
    'task_name' => 'testing task',
    'taskable_type' => 'Order',
    'taskable_id' => 123
]);

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Accept-Charset: utf-8',
    'Connection: keep-alive'
]);

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}

cost: curl_close($ch);

echo $response;

?>

```

```Java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class CreateTask {

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();

        String url = "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=";
        String requestBody = "{\"formatted_due_date\": \"11/11/2014\", \"task_name\": \"testing task\", \"taskable_type\": \"Order\", \"taskable_id\": 123}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .header("Accept-Charset", "utf-8")
            .header("Connection", "keep-alive")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();

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

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

```Go
package main

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

func main() {
	url := "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before="

	requestBody := []byte(`{
		"formatted_due_date": "11/11/2014",
		"task_name": "testing task",
		"taskable_type": "Order",
		"taskable_id": 123
	}`)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
	if err != nil {
		fmt.Printf("Error creating request: %s\n", err)
		return
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept-Charset", "utf-8")
	req.Header.Set("Connection", "keep-alive")

	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		fmt.Printf("Error sending request: %s\n", err)
		return
	}

	defer res.Body.Close()

	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %s\n", err)
		return
	}

	fmt.Printf("Status Code: %d\n", res.StatusCode)
	fmt.Printf("Response Body: %s\n", string(body))
}

```

```Ruby
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Accept-Charset"] = "utf-8"
request["Connection"] = "keep-alive"
request.body = JSON.dump({
  "formatted_due_date": "11/11/2014",
  "task_name": "testing task",
  "taskable_type": "Order",
  "taskable_id": 123
})

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

```C#
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class CreateTask {

    public static async Task Main(string[] args) {
        using (var client = new HttpClient())
        {
            var url = "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=";
            var requestBody = new StringContent(
                "{\"formatted_due_date\": \"11/11/2014\", \"task_name\": \"testing task\", \"taskable_type\": \"Order\", \"taskable_id\": 123}",
                Encoding.UTF8,
                "application/json"
            );

            client.DefaultRequestHeaders.Add("Accept-Charset", "utf-8");
            client.DefaultRequestHeaders.Add("Connection", "keep-alive");

            var response = await client.PostAsync(url, requestBody);

            var responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine($"Status Code: {response.StatusCode}");
            Console.WriteLine($"Response Body: {responseBody}");
        }
    }
}
```

```Perl
use strict;
use warnings;
use LWP::UserAgent;
use JSON;

my $url = "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=";

my $ua = LWP::UserAgent->new;
$ua->agent("MyPerlScript/1.0");

my $request_body = {
    'formatted_due_date' => '11/11/2014',
    'task_name' => 'testing task',
    'taskable_type' => 'Order',
    'taskable_id' => 123
};

my $response = $ua->post($url, Content => encode_json($request_body), 'Content_Type' => 'application/json', 'Accept-Charset' => 'utf-8', 'Connection' => 'keep-alive');

if ($response->is_success) {
    print $response->decoded_content;
} else {
    die "Error: " . $response->status_line;
}

```

```Objective-C
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before="];
        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];

        [request setHTTPMethod:@"POST"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setValue:@"utf-8" forHTTPHeaderField:@"Accept-Charset"];
        [request setValue:@"keep-alive" forHTTPHeaderField:@"Connection"];

        NSDictionary *bodyDict = @{
            @"formatted_due_date": @"11/11/2014",
            @"task_name": @"testing task",
            @"taskable_type": @"Order",
            @"taskable_id": @123
        };
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:bodyDict options:0 error:nil];
        [request setHTTPBody:jsonData];

        NSURLSession *session = [NSURLSession sharedSession];
        NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
            if (error) {
                NSLog(@"Error: %@\n", error.localizedDescription);
            } else {
                NSString *responseString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
                NSLog(@"Response Body: %@\n", responseString);
            }
        }];

        [dataTask resume];
        [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:5]]; // Keep the main thread alive for the network request
    }
    return 0;
}

```

```Swift
import Foundation

func createTask() {
    guard let url = URL(string: "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=") else { return }

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.setValue("utf-8", forHTTPHeaderField: "Accept-Charset")
    request.setValue("keep-alive", forHTTPHeaderField: "Connection")

    let bodyDict = [
        "formatted_due_date": "11/11/2014",
        "task_name": "testing task",
        "taskable_type": "Order",
        "taskable_id": 123
    ]

    guard let jsonData = try? JSONSerialization.data(withJSONObject: bodyDict, options: []) else { return }
    request.httpBody = jsonData

    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            print("Error: \(error.localizedDescription)\n")
        } else if let httpResponse = response as? HTTPURLResponse {
            if let responseData = data, let responseString = String(data: responseData, encoding: .utf8) {
                print("Status Code: \(httpResponse.statusCode)\n")
                print("Response Body: \(responseString)\n")
            }
        }
    }
    task.resume()
}

createTask()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 5)) // Keep the main thread alive for the network request

```

```Visual Basic
Imports System
Imports System.Net.Http
Imports System.Text
Imports System.Threading.Tasks

Public Class CreateTask

    Public Shared Async Function Main(args As String()) As Task
        Using client As New HttpClient()
            Dim url As String = "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before="
            Dim requestBody As New StringContent(
                "{\"formatted_due_date\": \"11/11/2014\", \"task_name\": \"testing task\", \"taskable_type\": \"Order\", \"taskable_id\": 123}",
                Encoding.UTF8,
                "application/json"
            )

            client.DefaultRequestHeaders.Add("Accept-Charset", "utf-8")
            client.DefaultRequestHeaders.Add("Connection", "keep-alive")

            Dim response As HttpResponseMessage = Await client.PostAsync(url, requestBody)

            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            Console.WriteLine($"Status Code: {response.StatusCode}")
            Console.WriteLine($"Response Body: {responseBody}")
        End Using
    End Function
End Class

```

```Groovy
import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.time.Duration

public class CreateTask {

    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();

        String url = "https://www.printavo.com/api/version/tasks?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&completed=&assigned_user_id=&included_orderstatus_ids=&taskable_type=&taskable_id=&due_after=&due_before=";

        Map<String, Object> bodyMap = [
            "formatted_due_date": "11/11/2014",
            "task_name": "testing task",
            "taskable_type": "Order",
            "taskable_id": 123
        ]
        String requestBody = JsonOutput.toJson(bodyMap)

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .header("Accept-Charset", "utf-8")
            .header("Connection", "keep-alive")
            .POST(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();

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

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

--------------------------------

### Printavo API Message Create Example (Go)

Source: https://printavo.docs.apiary.io/reference/messages/messages-collection/message-create

Example of how to create a message using the Printavo API in Go. This uses the standard 'net/http' package to perform the POST request.

```go
package main

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

func main() {
	url := "https://www.printavo.com/api/version/messages?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25"
	requestBody := []byte(`{
		"email_message": {
			"to": "elsie@cronin.name",
			"text": "Some text",
			"subject": "Subject",
			"cc_invoice_creator": true
		},
		"order_id": 1
	}`) 


	req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept-Charset", "utf-8")
	req.Header.Set("Connection", "keep-alive")

	client := &http.Client{}
	res, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}
	defer res.Body.Close()

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

	fmt.Println("Status Code:", res.StatusCode)
	fmt.Println("Response Body:", string(body))
}
```

--------------------------------

### Customers Index - cURL Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

Demonstrates how to fetch a list of customers using cURL. This command-line tool sends an HTTP GET request to the Printavo API with specified parameters for authentication and filtering.

```Shell
curl -X GET "https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false"
```

--------------------------------

### Fetch Expense Details - Swift Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using Swift. This snippet uses 'URLSession' for making HTTP GET requests.

```Swift
import Foundation

let urlString = "https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233"
guard let url = URL(string: urlString) else { return }

var request = URLRequest(url: url)
request.setValue("application/json", forHTTPHeaderField: "Accept")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error.localizedDescription)\n")
        return
    }
    guard let data = data else { return }
    if let responseString = String(data: data, encoding: .utf8) {
        print("Response: \(responseString)\n")
    }
}

task.resume()
```

--------------------------------

### Delivery Methods Index API Call (Go)

Source: https://printavo.docs.apiary.io/reference/delivery-methods/delivery-methods-collection/delivery-methods-index

This snippet provides a Go example for calling the Delivery Methods Index API. It outlines the process of making an HTTP GET request to the specified endpoint with query parameters. The response from the API is expected to be in JSON format.

```Go
// Go example would go here, using the 'net/http' package for HTTP GET requests.
```

--------------------------------

### Fetch Expense Details - Objective-C Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using Objective-C. This snippet uses 'NSURLSession' for making HTTP GET requests.

```Objective-C
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *urlString = @"https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233";
        NSURL *url = [NSURL URLWithString:urlString];
        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setValue:@"application/json" forHTTPHeaderField:@"Accept"];
        
        NSURLSession *session = [NSURLSession sharedSession];
        NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
            if (error) {
                NSLog(@"Error: %@\n", error.localizedDescription);
            } else {
                NSString *responseString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
                NSLog(@"Response: %@\n", responseString);
            }
        }];
        
        [task resume];
        
        // Keep the main thread alive to allow the network request to complete
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    }
    return 0;
}
```

--------------------------------

### Introduction

Source: https://printavo.docs.apiary.io/reference/inquiries/create-api

Provides a general overview of the Printavo API, including rate limiting information.

```APIDOC
## Introduction

This JSON-based API is used to access information in your Printavo account. Printavo is the simplest way for screen-printing, embroidering and promotional product shops to manage their business.

###### Rate Limiting

For API requests, we allow a limit of 10 requests for every 5 seconds by IP address or by user login email
```

--------------------------------

### Customers Index - Visual Basic Example

Source: https://printavo.docs.apiary.io/reference/customers/customers-collection/customers-index

Visual Basic example for making an API call to retrieve customers. This snippet would use classes like 'HttpClient' for making web requests.

```Visual Basic
' Visual Basic example using HttpClient:
' Imports System.Net.Http
' Imports System.Threading.Tasks
' 
' Public Class CustomerApiClient
'     Public Async Function GetCustomersAsync() As Task(Of String)
'         Using client As New HttpClient()
'             Dim url As String = "https://www.printavo.com/api/version/customers?email=test%40example.com&token=1dofnewoi233&page=1&per_page=25&sort_column=first_name&direction=asc&exclude_sub_customers=false"
'             Dim response As HttpResponseMessage = Await client.GetAsync(url)
'             response.EnsureSuccessStatusCode() ' Throw if not successful
'             Return Await response.Content.ReadAsStringAsync()
'         End Using
'     End Function
' End Class
```

--------------------------------

### Fetch Expense Details - PHP Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using PHP. This snippet demonstrates using cURL to make an HTTP GET request.

```PHP
<?php
$url = 'https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: application/json'));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
} else {
    echo $response;
}

curl_close($ch);
?>
```

--------------------------------

### Fetch Expense Details - Python Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using Python. This snippet uses the 'requests' library to make an HTTP GET request.

```Python
import requests

url = "https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233"
headers = {
    "Accept": "application/json"
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print(f"Error: {response.status_code}")
```

--------------------------------

### Introduction

Source: https://printavo.docs.apiary.io/reference/delivery-methods/create-api

Provides a general overview of the Printavo API, including its purpose and rate limiting policies.

```APIDOC
## Introduction

### Description
This JSON-based API is used to access information in your Printavo account. Printavo is the simplest way for screen-printing, embroidering and promotional product shops to manage their business.

### Rate Limiting
For API requests, we allow a limit of 10 requests for every 5 seconds by IP address or by user login email
```

--------------------------------

### API Introduction

Source: https://printavo.docs.apiary.io/reference/customers/create-api

Overview of the Printavo API and its capabilities, including rate limiting information.

```APIDOC
## Printavo API

### Introduction
This JSON-based API is used to access information in your Printavo account. Printavo is the simplest way for screen-printing, embroidering and promotional product shops to manage their business.

###### Rate Limiting
For API requests, we allow a limit of 10 requests for every 5 seconds by IP address or by user login email.
```

--------------------------------

### Fetch Expense Details - JavaScript Example

Source: https://printavo.docs.apiary.io/reference/expenses/expense/expense-show

Example of how to fetch expense details using JavaScript (Node.js fetch API). This demonstrates making an asynchronous HTTP GET request.

```JavaScript
const url = 'https://www.printavo.com/api/v1/expenses/27183?email=test@example.com&token=1dofnewoi233';

fetch(url, {
  method: 'GET',
  headers: {
    'Accept': 'application/json'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```
Tokens:
Raw