Remote Connection Guide

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "generate_barcode",
    "version": "1.0.0",
    "arguments": {
      "data": "Hello from MCP",
      "format": "QRCODE",
      "width": 200,
      "height": 200,
      "image_format": "PNG",
      "show_text": false
    }
  },
  "id": "call_YAgP8AgYLp5sVybdy0MvL1Co"
}

This example illustrates how parameters for barcode generation are passed. The structure follows JSON-RPC 2.0 for HTTP streaming.

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Http.Json; // Requires .NET 5+ or System.Net.Http.Json NuGet package
using System.Text;
using System.Text.Json; // For older .NET, use Newtonsoft.Json
using System.Threading.Tasks;

public class BarcodeGenerator
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task Main(string[] args)
    {
        string apiKey = "YOUR_API_KEY"; // Replace with your actual API key
        string apiUrl = "https://api.thebarcodeapi.com/api/barcode/generate";

        var payload = new
        {
            text = "Hello from C#",
            format = "qrcode", // e.g., qrcode, code128, ean13
            scale = 3,
            rotate = "N", // N, R, L
            background = "#ffffff",
            foreground = "#000000"
        };

        try
        {
            client.DefaultRequestHeaders.Clear();
            client.DefaultRequestHeaders.Add("X-API-Key", apiKey);
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); // Or "image/png" if you expect direct image

            // For .NET Core 3.1 and older, or .NET Framework without System.Net.Http.Json:
            // string jsonPayload = JsonSerializer.Serialize(payload);
            // HttpContent content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
            // HttpResponseMessage response = await client.PostAsync(apiUrl, content);

            // For .NET 5+ with System.Net.Http.Json:
            HttpResponseMessage response = await client.PostAsJsonAsync(apiUrl, payload);

            response.EnsureSuccessStatusCode();

            Console.WriteLine("API Request Successful!");

            // Option 1: Get image URL if API returns JSON with URL
            // string responseBody = await response.Content.ReadAsStringAsync();
            // Console.WriteLine("Response JSON: " + responseBody);
            // // Assuming JSON response: {"imageUrl": "...", "format": "..."}
            // // var result = JsonSerializer.Deserialize<Dictionary<string, string>>(responseBody);
            // // Console.WriteLine("Barcode Image URL: " + result["imageUrl"]);

            // Option 2: Save direct image stream (if API returns image/*)
            // Ensure your 'Accept' header is 'image/png' or similar
            if (response.Content.Headers.ContentType?.MediaType?.StartsWith("image/") == true)
            {
                var imageBytes = await response.Content.ReadAsByteArrayAsync();
                string fileName = $"barcode_{payload.format}.png"; // or jpg, etc.
                System.IO.File.WriteAllBytes(fileName, imageBytes);
                Console.WriteLine($"Barcode image saved as {fileName}");
            }
            else
            {
                 // Default: assume JSON response with details or error
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine("Response Body: " + responseBody);
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request error: {e.Message}");
            if (e.StatusCode.HasValue)
            {
                Console.WriteLine($"Status Code: {e.StatusCode.Value}");
            }
            // Optionally read error response body
            // if (e.HttpRequestError == HttpRequestError.BadResponse && e.Response != null)
            // {
            //     string errorContent = await e.Response.Content.ReadAsStringAsync();
            //     Console.WriteLine($"Error Content: {errorContent}");
            // }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
        }
    }
}

Remember to replace "YOUR_API_KEY" with your actual key. The code includes options for handling JSON responses (e.g., an image URL) or direct image data. Adjust the `Accept` header and response processing accordingly.

import requests
import json

def generate_barcode():
    api_key = "YOUR_API_KEY"  # Replace with your actual API key
    api_url = "https://api.thebarcodeapi.com/api/barcode/generate"

    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json",
        # "Accept": "image/png" # Uncomment if you want to receive the image directly
        "Accept": "application/json" # Default: expect a JSON response
    }

    payload = {
        "text": "Hello from Python",
        "format": "qrcode",  # e.g., qrcode, code128, datamatrix
        "scale": 3,
        "rotate": "N",  # N, R, L
        "background": "#ffffff",
        "foreground": "#000000"
    }

    try:
        response = requests.post(api_url, headers=headers, json=payload)
        response.raise_for_status()  # Raises an HTTPError for bad responses (4XX or 5XX)

        print("API Request Successful!")

        # Option 1: Handle JSON response (e.g., if API returns image URL)
        if "application/json" in response.headers.get("Content-Type", ""):
            data = response.json()
            print("Response JSON:", json.dumps(data, indent=2))
            # if "imageUrl" in data:
            #     print(f"Barcode Image URL: {data['imageUrl']}")
            #     # You can then download the image using data['imageUrl']
            #     # image_response = requests.get(data['imageUrl'])
            #     # with open(f"barcode_from_url.{data.get('format', 'png')}", "wb") as f:
            #     #     f.write(image_response.content)
            #     # print(f"Barcode saved as barcode_from_url.{data.get('format', 'png')}")

        # Option 2: Handle direct image response
        elif response.headers.get("Content-Type", "").startswith("image/"):
            image_format = response.headers.get("Content-Type").split("/")[-1]
            file_name = f"barcode.{image_format}"
            with open(file_name, "wb") as f:
                f.write(response.content)
            print(f"Barcode image saved as {file_name}")

        else:
            print(f"Unexpected content type: {response.headers.get('Content-Type')}");
            print("Raw response:", response.text);


    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}");
        print(f"Response content: {response.content.decode()}");
    except requests.exceptions.RequestException as req_err:
        print(f"Request error occurred: {req_err}");
    except Exception as ex:
        print(f"An unexpected error occurred: {ex}");

if __name__ == "__main__":
    generate_barcode()

Ensure you replace "YOUR_API_KEY". This script currently expects a JSON response. If the API is configured to send the image directly, you'll need to adjust the `Accept` header to something like "image/png" and modify the response handling to save `response.content` to a file.

async function generateBarcodeWithJS() {
  const apiKey = "YOUR_API_KEY"; // Replace with your actual API key
  const apiUrl = "https://api.thebarcodeapi.com/api/barcode/generate";

  const payload = {
    text: "Hello from JavaScript",
    format: "qrcode",
    scale: 3,
    rotate: "N",
    background: "#ffffff",
    foreground: "#000000"
    // output_format: "url" // to get a JSON response with URL
    // output_format: "image" // to get direct image (set Accept header accordingly)
  };

  const headers = {
    "X-API-Key": apiKey,
    "Content-Type": "application/json",
    // "Accept": "image/png" // Use this if you expect a direct image stream
    "Accept": "application/json" // Use this if you expect a JSON response
  };

  try {
    const response = await fetch(apiUrl, {
      method: "POST",
      headers: headers,
      body: JSON.stringify(payload)
    });

    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`HTTP error! status: ${response.status}, message: ${errorText}`);
    }

    console.log("API Request Successful!");

    const contentType = response.headers.get("content-type");

    if (contentType && contentType.includes("application/json")) {
      const data = await response.json();
      console.log("Response JSON:", data);
      // Example: if (data.imageUrl) { console.log("Barcode Image URL:", data.imageUrl); }
      // If using in browser, you could set an image src:
      // document.getElementById('barcodeImage').src = data.imageUrl;
    } else if (contentType && contentType.startsWith("image/")) {
      const imageBlob = await response.blob();
      console.log("Received image data (blob).");
      // Example: In a browser, you can create an object URL and display the image
      // const imageUrl = URL.createObjectURL(imageBlob);
      // document.getElementById('barcodeImage').src = imageUrl;
      // For Node.js, you might convert blob to buffer and save to file:
      // const buffer = Buffer.from(await imageBlob.arrayBuffer());
      // require('fs').writeFileSync('barcode.png', buffer);
      // console.log('Barcode image saved as barcode.png');
    } else {
      const textData = await response.text();
      console.log("Received text data:", textData);
    }

  } catch (error) {
    console.error("Error generating barcode:", error);
  }
}

// Call the function
generateBarcodeWithJS();

// Example HTML structure if running in browser:
// <img id="barcodeImage" alt="Barcode will appear here" />

Remember to replace "YOUR_API_KEY". This example provides comments for handling both JSON (e.g., with an image URL) and direct image blob responses. Adjust the `Accept` header and `output_format` in payload according to your needs.