Tùy chọn 1: Sử dụng URL hình ảnh

const response = await fetch('https://thegendai.com/api/v1/generate-description', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'your_api_key_here'
  },
  body: JSON.stringify({
    brand_description: 'Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách',
    audience: 'Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững',
    tone_voice: 'Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường',
    languages: ['english', 'spanish'],
    product: {
      name: 'Chai nước tre',
      category: 'Thân thiện với môi trường',
      price: '24.99',
      image_url: 'https://example.com/product-image.jpg'
    }
  })
});

const data = await response.json();
console.log(data);

Tùy chọn 2: Sử dụng hình ảnh Base64

// Convert file to base64
function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => resolve(reader.result.split(',')[1]);
    reader.onerror = error => reject(error);
  });
}

// Usage with file input
const fileInput = document.getElementById('imageFile');
const file = fileInput.files[0];
const base64Image = await fileToBase64(file);

const response = await fetch('https://thegendai.com/api/v1/generate-description', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'your_api_key_here'
  },
  body: JSON.stringify({
    brand_description: 'Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách',
    audience: 'Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững',
    tone_voice: 'Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường',
    languages: ['english', 'spanish'],
    product: {
      name: 'Chai nước tre',
      category: 'Thân thiện với môi trường',
      price: '24.99',
      image_b64: base64Image
    }
  })
});

const data = await response.json();
console.log(data);

Tùy chọn 1: Sử dụng URL hình ảnh

import requests

url = "https://thegendai.com/api/v1/generate-description"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "your_api_key_here"
}
data = {
    "brand_description": "Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách",
    "audience": "Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững",
    "tone_voice": "Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường",
    "languages": ["english", "spanish"],
    "product": {
        "name": "Chai nước tre",
        "category": "Thân thiện với môi trường",
        "price": "24.99",
        "image_url": "https://example.com/product-image.jpg"
    }
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result)

Tùy chọn 2: Sử dụng hình ảnh Base64

import requests
import base64

# Read and encode image file
def encode_image_to_base64(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

url = "https://thegendai.com/api/v1/generate-description"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "your_api_key_here"
}

# Encode the image
image_b64 = encode_image_to_base64("path/to/your/image.jpg")

data = {
    "brand_description": "Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách",
    "audience": "Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững",
    "tone_voice": "Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường",
    "languages": ["english", "spanish"],
    "product": {
        "name": "Chai nước tre",
        "category": "Thân thiện với môi trường",
        "price": "24.99",
        "image_b64": image_b64
    }
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result)

<?php

$url = "https://thegendai.com/api/v1/generate-description";
$headers = [
    'Content-Type: application/json',
    'X-API-Key: your_api_key_here'
];

$data = [
    'brand_description' => 'Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách',
    'audience' => 'Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững',
    'tone_voice' => 'Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường',
    'languages' => ['english', 'spanish'],
    'product' => [
        'name' => 'Chai nước tre',
        'category' => 'Thân thiện với môi trường',
        'price' => '24.99',
        'image_url' => 'https://example.com/product-image.jpg'
    ]
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 200) {
    $result = json_decode($response, true);
    print_r($result);
} else {
    echo "Error: " . $response;
}

?>

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class TheGendaiAPIClient {
    private static final String API_URL = "https://thegendai.com/api/v1/generate-description";
    private static final String API_KEY = "your_api_key_here";

    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        ObjectMapper mapper = new ObjectMapper();

        // Create request payload
        ObjectNode payload = mapper.createObjectNode();
        payload.put("brand_description", "Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách");
        payload.put("audience", "Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững");
        payload.put("tone_voice", "Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường");

        ArrayNode languages = mapper.createArrayNode();
        languages.add("english");
        languages.add("spanish");
        payload.set("languages", languages);

        ObjectNode product = mapper.createObjectNode();
        product.put("name", "Chai nước tre");
        product.put("category", "Thân thiện với môi trường");
        product.put("price", "24.99");
        product.put("image_url", "https://example.com/product-image.jpg");
        payload.set("product", product);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .header("X-API-Key", API_KEY)
                .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(payload)))
                .build();

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

        if (response.statusCode() == 200) {
            System.out.println("Success: " + response.body());
        } else {
            System.err.println("Error: " + response.body());
        }
    }
}

#!/bin/bash

# Configuration
API_URL="https://thegendai.com/api/v1/generate-description"
API_KEY="your_api_key_here"

# JSON payload
PAYLOAD='{
  "brand_description": "Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách",
  "audience": "Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững",
  "tone_voice": "Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường",
  "languages": ["english", "spanish"],
  "product": {
    "name": "Chai nước tre",
    "category": "Thân thiện với môi trường",
    "price": "24.99",
    "image_url": "https://example.com/product-image.jpg"
  }
}'

# Make the API request
response=$(curl -s -w "HTTPSTATUS:%{http_code}" \
  -X POST "$API_URL" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -d "$PAYLOAD")

# Extract HTTP status code and body
http_code=$(echo "$response" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
body=$(echo "$response" | sed -e 's/HTTPSTATUS\:.*//g')

# Check response
if [ "$http_code" -eq 200 ]; then
    echo "Success:"
    echo "$body" | jq '.'
else
    echo "Error (HTTP $http_code):"
    echo "$body"
fi

require 'net/http'
require 'json'
require 'uri'

class TheGendaiAPIClient
  API_URL = "https://thegendai.com/api/v1/generate-description"

  def initialize(api_key)
    @api_key = api_key
  end

  def generate_description(brand_description:, audience:, tone_voice:, languages:, product:)
    uri = URI(API_URL)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true if uri.scheme == 'https'

    request = Net::HTTP::Post.new(uri)
    request['Content-Type'] = 'application/json'
    request['X-API-Key'] = @api_key

    payload = {
      brand_description: brand_description,
      audience: audience,
      tone_voice: tone_voice,
      languages: languages,
      product: product
    }

    request.body = payload.to_json

    response = http.request(request)

    case response.code.to_i
    when 200
      JSON.parse(response.body)
    else
      raise "API Error (#{response.code}): #{response.body}"
    end
  end
end

# Usage example
client = TheGendaiAPIClient.new('your_api_key_here')

begin
  result = client.generate_description(
    brand_description: 'Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách',
    audience: 'Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững',
    tone_voice: 'Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường',
    languages: ['english', 'spanish'],
    product: {
      name: 'Chai nước tre',
      category: 'Thân thiện với môi trường',
      price: '24.99',
      image_url: 'https://example.com/product-image.jpg'
    }
  )

  puts "Success: #{result}"
rescue => e
  puts "Error: #{e.message}"
end

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class TheGendaiApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private const string ApiUrl = "https://thegendai.com/api/v1/generate-description";

    public TheGendaiApiClient(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("X-API-Key", _apiKey);
    }

    public async Task<string> GenerateDescriptionAsync()
    {
        var payload = new
        {
            brand_description = "Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách",
            audience = "Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững",
            tone_voice = "Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường",
            languages = new[] { "english", "spanish" },
            product = new
            {
                name = "Chai nước tre",
                category = "Thân thiện với môi trường",
                price = "24.99",
                image_url = "https://example.com/product-image.jpg"
            }
        };

        var jsonContent = JsonSerializer.Serialize(payload);
        var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

        try
        {
            var response = await _httpClient.PostAsync(ApiUrl, content);

            if (response.IsSuccessStatusCode)
            {
                return await response.Content.ReadAsStringAsync();
            }
            else
            {
                var errorContent = await response.Content.ReadAsStringAsync();
                throw new Exception($"API Error ({response.StatusCode}): {errorContent}");
            }
        }
        catch (HttpRequestException ex)
        {
            throw new Exception($"Request failed: {ex.Message}");
        }
    }

    public void Dispose()
    {
        _httpClient?.Dispose();
    }
}

// Usage example
class Program
{
    static async Task Main(string[] args)
    {
        var client = new TheGendaiApiClient("your_api_key_here");

        try
        {
            string result = await client.GenerateDescriptionAsync();
            Console.WriteLine($"Success: {result}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally
        {
            client.Dispose();
        }
    }
}

package main

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

type Product struct {
    Name     string `json:"name"`
    Category string `json:"category"`
    Price    string `json:"price"`
    ImageURL string `json:"image_url"`
}

type APIRequest struct {
    BrandDescription     string   `json:"brand_description"`
    Audience            string   `json:"audience"`
    ToneVoice           string   `json:"tone_voice"`
    Languages           []string `json:"languages"`
    Product             Product  `json:"product"`
}

type APIResponse struct {
    Success bool        `json:"success"`
    Data    interface{} `json:"data"`
    Error   string      `json:"error,omitempty"`
}

func generateDescription(apiKey string) (*APIResponse, error) {
    const apiURL = "https://thegendai.com/api/v1/generate-description"

    // Create request payload
    reqData := APIRequest{
        BrandDescription: "Chúng tôi tạo ra các sản phẩm thân thiện với môi trường cao cấp kết hợp tính bền vững với phong cách",
        Audience:        "Người tiêu dùng có ý thức về môi trường coi trọng chất lượng và tính bền vững",
        ToneVoice:       "Chuyên nghiệp nhưng dễ tiếp cận, nhấn mạnh chất lượng và lợi ích môi trường",
        Languages:       []string{"english", "spanish"},
        Product: Product{
            Name:     "Chai nước tre",
            Category: "Thân thiện với môi trường",
            Price:    "24.99",
            ImageURL: "https://example.com/product-image.jpg",
        },
    }

    // Marshal to JSON
    jsonData, err := json.Marshal(reqData)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal request: %w", err)
    }

    // Create HTTP request
    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    // Set headers
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", apiKey)

    // Make request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("failed to make request: %w", err)
    }
    defer resp.Body.Close()

    // Read response
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response: %w", err)
    }

    // Parse response
    var apiResp APIResponse
    if err := json.Unmarshal(body, &apiResp); err != nil {
        return nil, fmt.Errorf("failed to parse response: %w", err)
    }

    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, apiResp.Error)
    }

    return &apiResp, nil
}

func main() {
    apiKey := "your_api_key_here"

    result, err := generateDescription(apiKey)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Success: %+v\n", result)
}

Tích hợp Quy trình Làm việc N8N

Quy trình làm việc N8N này minh họa cách tích hợp The Gendai API vào các quy trình làm việc tự động hóa của bạn.

@__raw_block_0__{{ url('/') }}/api/v1/generate-description",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Content-Type",
              "value": "application/json"
            },
            {
              "name": "X-API-Key",
              "value": "YOUR_API_KEY_HERE"
            }
          ]
        },
        "sendBody": true,
        "jsonBody": "={{ $json.api_payload }}",
        "options": {}
      },
      "id": "api-call",
      "name": "Generate Descriptions",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [900, 300]
    }
  ],
  "connections": {
    "Manual Trigger": {
      "main": [
        [
          {
            "node": "Set Brand Info",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Brand Info": {
      "main": [
        [
          {
            "node": "Prepare API Call",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Prepare API Call": {
      "main": [
        [
          {
            "node": "Generate Descriptions",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {}
}