Go HTTP Patterns

Use Go's standard library (net/http) to integrate with the FOTOhub API. There is no official Go SDK — these patterns show idiomatic, production-ready HTTP integration using only the standard library.

No SDK Required

Go's net/http package is powerful enough for direct API integration. The patterns below give you a reusable client with retries, streaming, async polling, file uploads, webhook verification, and rate limiting — all without third-party dependencies.

Reusable Client Struct

A production-ready HTTP client with base URL configuration, automatic retries with exponential backoff, and configurable timeouts. Use a single instance across your application — it is safe for concurrent use.

PythonTypeScriptGocURL

python

from fotohub import FotoHub

client = FotoHub(
    api_key="fh_live_your_api_key",
    max_retries=3,
    timeout=30.0
)

typescript

import { FotoHub } from "fotohub";

const client = new FotoHub({ 
    apiKey: "fh_live_your_api_key",
    maxRetries: 3,
    timeout: 30000
});

package main

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

type FotoHubClient struct {
    APIKey     string
    BaseURL    string
    HTTPClient *http.Client
}

func NewFotoHubClient(apiKey string) *FotoHubClient {
    return &FotoHubClient{
        APIKey:  apiKey,
        BaseURL: "https://apis.fotohub.app/v1",
        HTTPClient: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

func (c *FotoHubClient) Post(ctx context.Context, path string, body interface{}) ([]byte, error) {
    var reqBody io.Reader
    if body != nil {
        jsonBody, err := json.Marshal(body)
        if err != nil {
            return nil, err
        }
        reqBody = bytes.NewReader(jsonBody)
    }

    req, err := http.NewRequestWithContext(ctx, "POST", c.BaseURL+path, reqBody)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    respBody, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    if resp.StatusCode >= 400 {
        return nil, fmt.Errorf("API error: %s - %s", resp.Status, string(respBody))
    }

    return respBody, nil
}

bash

# Client configuration is not applicable to cURL

Image Generation

API endpoints and wrappers for Image Generation. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.images.generate(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.images.generate({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type GenerateImageRequest struct {
    Param string `json:"param"`
}

type GenerateImageResponse struct {
    URL string `json:"url"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func GenerateImage(ctx context.Context, client *FotoHubClient, req GenerateImageRequest) (*GenerateImageResponse, error) {
    respData, err := client.Post(ctx, "/ai/generate/image", req)
    if err != nil {
        return nil, err
    }
    
    var result GenerateImageResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/generate/image \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Video Generation

API endpoints and wrappers for Video Generation. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.videos.generate(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.videos.generate({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type GenerateVideoRequest struct {
    Param string `json:"param"`
}

type GenerateVideoResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func GenerateVideo(ctx context.Context, client *FotoHubClient, req GenerateVideoRequest) (*GenerateVideoResponse, error) {
    respData, err := client.Post(ctx, "/ai/generate/video", req)
    if err != nil {
        return nil, err
    }
    
    var result GenerateVideoResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/generate/video \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Audio & TTS

Calls POST /v1/ai/generate/speech. In the Python and TypeScript SDKs this is generate_speech() / generateSpeech() — there is no client.audio namespace.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.generate_speech(text="Hello from FOTOhub")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.generateSpeech({ text: "Hello from FOTOhub" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type GenerateAudioRequest struct {
    Param string `json:"param"`
}

type GenerateAudioResponse struct {
    URL string `json:"url"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func GenerateAudio(ctx context.Context, client *FotoHubClient, req GenerateAudioRequest) (*GenerateAudioResponse, error) {
    respData, err := client.Post(ctx, "/v1/ai/generate/speech", req)
    if err != nil {
        return nil, err
    }
    
    var result GenerateAudioResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/generate/speech \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Document Intelligence

Calls POST /v1/ai/document/analyze. No SDK ships a documents wrapper — call the endpoint directly.

PythonTypeScriptGocURL

python

import httpx
res = httpx.post(
    "https://apis.fotohub.app/v1/ai/document/analyze",
    headers={"Authorization": "Bearer fh_live_your_api_key"},
    json={"document_base64": "..."},
).json()
print(res)

typescript

const res = await fetch("https://apis.fotohub.app/v1/ai/document/analyze", {
  method: "POST",
  headers: { Authorization: "Bearer fh_live_your_api_key", "Content-Type": "application/json" },
  body: JSON.stringify({ document_base64: "..." }),
}).then((r) => r.json());
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type AnalyzeDocumentRequest struct {
    Param string `json:"param"`
}

type AnalyzeDocumentResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func AnalyzeDocument(ctx context.Context, client *FotoHubClient, req AnalyzeDocumentRequest) (*AnalyzeDocumentResponse, error) {
    respData, err := client.Post(ctx, "/v1/ai/document/analyze", req)
    if err != nil {
        return nil, err
    }
    
    var result AnalyzeDocumentResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/document/analyze \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Brand Engine

Calls POST /brand/v1/brands. No SDK ships a brands wrapper — call the endpoint directly.

PythonTypeScriptGocURL

python

import httpx
res = httpx.post(
    "https://apis.fotohub.app/brand/v1/brands",
    headers={"Authorization": "Bearer fh_live_your_api_key"},
    json={"name": "Acme Corp"},
).json()
print(res)

typescript

const res = await fetch("https://apis.fotohub.app/brand/v1/brands", {
  method: "POST",
  headers: { Authorization: "Bearer fh_live_your_api_key", "Content-Type": "application/json" },
  body: JSON.stringify({ name: "Acme Corp" }),
}).then((r) => r.json());
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type CreateBrandRequest struct {
    Param string `json:"param"`
}

type CreateBrandResponse struct {
    BrandID string `json:"brandid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func CreateBrand(ctx context.Context, client *FotoHubClient, req CreateBrandRequest) (*CreateBrandResponse, error) {
    respData, err := client.Post(ctx, "/brand/v1/brands", req)
    if err != nil {
        return nil, err
    }
    
    var result CreateBrandResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/brand/v1/brands \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Calls POST /social/v1/posts (create a post; include a scheduled_at field to schedule it). No SDK ships a social wrapper — call the endpoint directly.

PythonTypeScriptGocURL

python

import httpx
res = httpx.post(
    "https://apis.fotohub.app/social/v1/posts",
    headers={"Authorization": "Bearer fh_live_your_api_key"},
    json={"caption": "New drop!", "scheduled_at": "2026-10-01T14:00:00Z"},
).json()
print(res)

typescript

const res = await fetch("https://apis.fotohub.app/social/v1/posts", {
  method: "POST",
  headers: { Authorization: "Bearer fh_live_your_api_key", "Content-Type": "application/json" },
  body: JSON.stringify({ caption: "New drop!", scheduled_at: "2026-10-01T14:00:00Z" }),
}).then((r) => r.json());
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type SchedulePostRequest struct {
    Param string `json:"param"`
}

type SchedulePostResponse struct {
    PostID string `json:"postid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func SchedulePost(ctx context.Context, client *FotoHubClient, req SchedulePostRequest) (*SchedulePostResponse, error) {
    respData, err := client.Post(ctx, "/social/v1/posts", req)
    if err != nil {
        return nil, err
    }
    
    var result SchedulePostResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/social/v1/posts \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Virtual Try-On

Calls POST /v1/ai/tryon. The Python SDK exposes this as the flat client.tryon() — there is no client.tryon.submit().

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.tryon(
    person_image_url="https://example.com/person.jpg",
    garment_image_url="https://example.com/shirt.jpg",
    category="tops",
)
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.tryOn({
  personImageUrl: "https://example.com/person.jpg",
  garmentImageUrl: "https://example.com/shirt.jpg",
  category: "tops",
});
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type SubmitTryonRequest struct {
    Param string `json:"param"`
}

type SubmitTryonResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func SubmitTryon(ctx context.Context, client *FotoHubClient, req SubmitTryonRequest) (*SubmitTryonResponse, error) {
    respData, err := client.Post(ctx, "/v1/ai/tryon", req)
    if err != nil {
        return nil, err
    }
    
    var result SubmitTryonResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/ai/tryon \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter

Shorts & Clips

API endpoints and wrappers for Shorts & Clips. Ensure proper pure USD tracking.

PythonTypeScriptGocURL

python

from fotohub import FotoHub
client = FotoHub(api_key="fh_live_your_api_key")
res = client.clips.submit(param="value")
print(res)

typescript

import { FotoHub } from "fotohub";
const client = new FotoHub({ apiKey: "fh_live_your_api_key" });
const res = await client.clips.submit({ param: "value" });
console.log(res);

package main

import (
    "context"
    "encoding/json"
)

type SubmitClippingRequest struct {
    Param string `json:"param"`
}

type SubmitClippingResponse struct {
    JobID string `json:"jobid"`
    Billing struct {
        USDCharged float64 `json:"usd_charged"`
    } `json:"billing"`
}

func SubmitClipping(ctx context.Context, client *FotoHubClient, req SubmitClippingRequest) (*SubmitClippingResponse, error) {
    respData, err := client.Post(ctx, "/shorts/clips", req)
    if err != nil {
        return nil, err
    }
    
    var result SubmitClippingResponse
    if err := json.Unmarshal(respData, &result); err != nil {
        return nil, err
    }
    return &result, nil
}

bash

curl -X POST https://apis.fotohub.app/v1/shorts/clips \
  -H "Authorization: Bearer fh_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"param": "value"}'

Field	Type	Required	Default	Description
`param`	string	Yes	-	The parameter