Documentació de l'API de MakeFav

Pujada multipart:

Copia# Multipart upload (recommended). --fail-with-body exits non-zero on HTTP errors
# and still saves the JSON error body, so you can inspect it.
curl --fail-with-body -sS https://makefav.com/api/v1/generate \
  -H "Authorization: Bearer $MAKEFAV_API_KEY" \
  -F "[email protected]" \
  -F "app_name=My App" \
  -F "theme_color=#2f9e68" \
  -F "radius=20" \
  -o favicons.zip \
  || { echo "Request failed:"; cat favicons.zip; rm -f favicons.zip; exit 1; }

Cos JSON amb una imatge codificada en base64 (requereix jq):

Copia# JSON body with a base64-encoded image (built with jq to avoid argument length limits)
base64 < logo.png | tr -d '\n' > logo.b64
jq -n --rawfile img logo.b64 \
  '{image_base64: $img, app_name: "My App", theme_color: "#2f9e68", radius: 20}' \
| curl --fail-with-body -sS https://makefav.com/api/v1/generate \
    -H "Authorization: Bearer $MAKEFAV_API_KEY" \
    -H "Content-Type: application/json" \
    --data-binary @- \
    -o favicons.zip \
  || { echo "Request failed:"; cat favicons.zip; rm -f favicons.zip; exit 1; }

Copia<?php
// Requires the curl extension. Run: MAKEFAV_API_KEY=mf_... php favicons.php
$apiKey = getenv('MAKEFAV_API_KEY') ?: exit("Set MAKEFAV_API_KEY first\n");

$ch = curl_init('https://makefav.com/api/v1/generate');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 60,
    CURLOPT_HTTPHEADER     => ['Authorization: Bearer ' . $apiKey],
    CURLOPT_POSTFIELDS     => [
        'image'       => new CURLFile('logo.png', 'image/png', 'logo.png'),
        'app_name'    => 'My App',
        'theme_color' => '#2f9e68',
        'radius'      => '20',
    ],
]);

$body = curl_exec($ch);
if ($body === false) {
    fwrite(STDERR, 'Request failed: ' . curl_error($ch) . PHP_EOL);
    exit(1);
}

$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status !== 200) {
    $error = json_decode($body, true)['error'] ?? ['code' => 'http_' . $status, 'message' => substr($body, 0, 200)];
    fwrite(STDERR, "Error {$status} {$error['code']}: {$error['message']}" . PHP_EOL);
    exit(1);
}

file_put_contents('favicons.zip', $body);
echo 'Saved favicons.zip (' . strlen($body) . " bytes)\n";

Copia# pip install requests  ·  Run: MAKEFAV_API_KEY=mf_... python favicons.py
import os
import sys

import requests

API_KEY = os.environ["MAKEFAV_API_KEY"]

try:
    with open("logo.png", "rb") as logo:
        resp = requests.post(
            "https://makefav.com/api/v1/generate",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"image": ("logo.png", logo, "image/png")},
            data={"app_name": "My App", "theme_color": "#2f9e68", "radius": 20},
            timeout=60,
        )
except requests.RequestException as exc:
    sys.exit(f"Request failed: {exc}")

if resp.status_code != 200:
    try:
        err = resp.json()["error"]
        sys.exit(f"Error {resp.status_code} {err['code']}: {err['message']}")
    except (ValueError, KeyError, TypeError):
        sys.exit(f"Error {resp.status_code}: {resp.text[:200]}")

with open("favicons.zip", "wb") as out:
    out.write(resp.content)

remaining = resp.headers.get("X-RateLimit-Remaining")
print(f"Saved favicons.zip ({len(resp.content)} bytes), {remaining} requests left this hour")

Copia// favicons.mjs — Node.js 18+, no dependencies. Run: MAKEFAV_API_KEY=mf_... node favicons.mjs
import { readFile, writeFile } from 'node:fs/promises';

const form = new FormData();
form.append('image', new Blob([await readFile('logo.png')], { type: 'image/png' }), 'logo.png');
form.append('app_name', 'My App');
form.append('theme_color', '#2f9e68');
form.append('radius', '20');

const res = await fetch('https://makefav.com/api/v1/generate', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.MAKEFAV_API_KEY}` },
  body: form,
});

if (!res.ok) {
  const body = await res.json().catch(() => null);
  console.error(`Error ${res.status} ${body?.error?.code ?? ''}: ${body?.error?.message ?? res.statusText}`);
  process.exit(1);
}

await writeFile('favicons.zip', Buffer.from(await res.arrayBuffer()));
console.log(`Saved favicons.zip, ${res.headers.get('x-ratelimit-remaining')} requests left this hour`);

Copia<input type="file" id="logo" accept="image/*">
<button type="button" id="go">Generate favicons</button>

<script>
// Never put your API key in browser code. Point ENDPOINT at your own backend route,
// which forwards the multipart body to https://makefav.com/api/v1/generate and adds
// the "Authorization: Bearer mf_..." header on the server.
const ENDPOINT = '/my-backend/favicons';

document.getElementById('go').addEventListener('click', async () => {
  const file = document.getElementById('logo').files[0];
  if (!file) {
    alert('Please choose an image first.');
    return;
  }

  const form = new FormData();
  form.append('image', file);
  form.append('app_name', 'My App');
  form.append('theme_color', '#2f9e68');
  form.append('radius', '20');

  try {
    const res = await fetch(ENDPOINT, { method: 'POST', body: form });
    if (!res.ok) {
      const body = await res.json().catch(() => null);
      throw new Error(body?.error?.message || `HTTP ${res.status}`);
    }
    const url = URL.createObjectURL(await res.blob());
    const a = Object.assign(document.createElement('a'), { href: url, download: 'favicons.zip' });
    document.body.append(a);
    a.click();
    a.remove();
    setTimeout(() => URL.revokeObjectURL(url), 1000);
  } catch (err) {
    alert('Favicon generation failed: ' + err.message);
  }
});
</script>

Copia// go run favicons.go  (MAKEFAV_API_KEY must be set)
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"os"
	"time"
)

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func run() error {
	var body bytes.Buffer
	w := multipart.NewWriter(&body)

	logo, err := os.ReadFile("logo.png")
	if err != nil {
		return err
	}
	h := make(textproto.MIMEHeader)
	h.Set("Content-Disposition", `form-data; name="image"; filename="logo.png"`)
	h.Set("Content-Type", "image/png")
	part, err := w.CreatePart(h)
	if err != nil {
		return err
	}
	if _, err := part.Write(logo); err != nil {
		return err
	}
	for k, v := range map[string]string{"app_name": "My App", "theme_color": "#2f9e68", "radius": "20"} {
		if err := w.WriteField(k, v); err != nil {
			return err
		}
	}
	if err := w.Close(); err != nil {
		return err
	}

	req, err := http.NewRequest(http.MethodPost, "https://makefav.com/api/v1/generate", &body)
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("MAKEFAV_API_KEY"))
	req.Header.Set("Content-Type", w.FormDataContentType())

	client := &http.Client{Timeout: 60 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		var apiErr struct {
			Error struct {
				Code    string `json:"code"`
				Message string `json:"message"`
			} `json:"error"`
		}
		_ = json.NewDecoder(resp.Body).Decode(&apiErr)
		return fmt.Errorf("error %d %s: %s", resp.StatusCode, apiErr.Error.Code, apiErr.Error.Message)
	}

	zip, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if err := os.WriteFile("favicons.zip", zip, 0o644); err != nil {
		return err
	}
	fmt.Printf("Saved favicons.zip (%d bytes)\n", len(zip))
	return nil
}

Copia# ruby favicons.rb  (MAKEFAV_API_KEY must be set) — standard library only
require "net/http"
require "json"
require "uri"

uri = URI("https://makefav.com/api/v1/generate")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV.fetch("MAKEFAV_API_KEY")}"

res = File.open("logo.png", "rb") do |logo|
  req.set_form(
    [
      ["image", logo, { filename: "logo.png", content_type: "image/png" }],
      ["app_name", "My App"],
      ["theme_color", "#2f9e68"],
      ["radius", "20"]
    ],
    "multipart/form-data"
  )
  Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 60) { |http| http.request(req) }
end

unless res.is_a?(Net::HTTPSuccess)
  err = (JSON.parse(res.body)["error"] rescue nil) || { "code" => res.code, "message" => res.body.to_s[0, 200] }
  abort "Error #{res.code} #{err["code"]}: #{err["message"]}"
end

File.binwrite("favicons.zip", res.body)
puts "Saved favicons.zip (#{res.body.bytesize} bytes)"

Copia// .NET 6+ console app (Program.cs, top-level statements, implicit usings enabled)
using System.Net.Http.Headers;
using System.Text.Json;

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(60) };
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("MAKEFAV_API_KEY"));

using var form = new MultipartFormDataContent();
var image = new ByteArrayContent(await File.ReadAllBytesAsync("logo.png"));
image.Headers.ContentType = new MediaTypeHeaderValue("image/png");
form.Add(image, "image", "logo.png");
form.Add(new StringContent("My App"), "app_name");
form.Add(new StringContent("#2f9e68"), "theme_color");
form.Add(new StringContent("20"), "radius");

using var response = await http.PostAsync("https://makefav.com/api/v1/generate", form);
if (!response.IsSuccessStatusCode)
{
    var body = await response.Content.ReadAsStringAsync();
    string code = "", message = body;
    try
    {
        var error = JsonDocument.Parse(body).RootElement.GetProperty("error");
        code = error.GetProperty("code").GetString() ?? "";
        message = error.GetProperty("message").GetString() ?? "";
    }
    catch (Exception e) when (e is JsonException or KeyNotFoundException or InvalidOperationException) { }
    Console.Error.WriteLine($"Error {(int)response.StatusCode} {code}: {message}");
    return 1;
}

await File.WriteAllBytesAsync("favicons.zip", await response.Content.ReadAsByteArrayAsync());
Console.WriteLine("Saved favicons.zip");
return 0;

Copia// Java 11+, no dependencies. Run: MAKEFAV_API_KEY=mf_... java MakeFav.java
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;

public class MakeFav {
    public static void main(String[] args) throws IOException, InterruptedException {
        String boundary = "----MakeFav" + UUID.randomUUID().toString().replace("-", "");

        Map<String, String> fields = new LinkedHashMap<>();
        fields.put("app_name", "My App");
        fields.put("theme_color", "#2f9e68");
        fields.put("radius", "20");

        // Build the multipart/form-data body by hand
        ByteArrayOutputStream body = new ByteArrayOutputStream();
        for (Map.Entry<String, String> field : fields.entrySet()) {
            body.write(("--" + boundary + "\r\n"
                + "Content-Disposition: form-data; name=\"" + field.getKey() + "\"\r\n\r\n"
                + field.getValue() + "\r\n").getBytes(StandardCharsets.UTF_8));
        }
        body.write(("--" + boundary + "\r\n"
            + "Content-Disposition: form-data; name=\"image\"; filename=\"logo.png\"\r\n"
            + "Content-Type: image/png\r\n\r\n").getBytes(StandardCharsets.UTF_8));
        body.write(Files.readAllBytes(Path.of("logo.png")));
        body.write(("\r\n--" + boundary + "--\r\n").getBytes(StandardCharsets.UTF_8));

        HttpRequest request = HttpRequest.newBuilder(URI.create("https://makefav.com/api/v1/generate"))
            .timeout(Duration.ofSeconds(60))
            .header("Authorization", "Bearer " + System.getenv("MAKEFAV_API_KEY"))
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofByteArray(body.toByteArray()))
            .build();

        HttpResponse<byte[]> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofByteArray());

        if (response.statusCode() != 200) {
            // Error body is JSON: {"error":{"code":"...","message":"..."}}
            System.err.println("Error " + response.statusCode() + ": "
                + new String(response.body(), StandardCharsets.UTF_8));
            System.exit(1);
        }

        Files.write(Path.of("favicons.zip"), response.body());
        System.out.println("Saved favicons.zip (" + response.body().length + " bytes)");
    }
}

Flux de treball de GitHub Actions: format JSON, fitxers descodificats amb jq:

Copia# .github/workflows/favicons.yml — regenerate favicons whenever the logo changes.
# Add your key as a repository secret named MAKEFAV_API_KEY.
name: Favicons

on:
  push:
    paths: ['branding/logo.png']
  workflow_dispatch:

jobs:
  favicons:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Generate favicon package (JSON format)
        env:
          MAKEFAV_API_KEY: ${{ secrets.MAKEFAV_API_KEY }}
        run: |
          set -euo pipefail
          curl --fail-with-body -sS https://makefav.com/api/v1/generate \
            -H "Authorization: Bearer $MAKEFAV_API_KEY" \
            -F "image=@branding/logo.png" \
            -F "app_name=My App" \
            -F "theme_color=#2f9e68" \
            -F "radius=20" \
            -F "path=/icons/" \
            -F "format=json" \
            -o favicons.json || { cat favicons.json; exit 1; }

          mkdir -p public/icons
          # Decode every file from the JSON response (jq is preinstalled on GitHub runners)
          jq -r '.files[] | "\(.name) \(.base64)"' favicons.json |
            while read -r name data; do
              printf '%s' "$data" | base64 -d > "public/icons/$(basename "$name")"
            done
          jq -r '.html' favicons.json > public/icons/head-snippet.html
          ls -l public/icons

      - uses: actions/upload-artifact@v4
        with:
          name: favicons
          path: public/icons

Script d'intèrpret d'ordres senzill per a qualsevol CI: format ZIP:

Copia#!/usr/bin/env bash
# scripts/favicons.sh — simpler variant for any CI or build step: fetch the ZIP and unpack it.
set -euo pipefail
: "${MAKEFAV_API_KEY:?Set MAKEFAV_API_KEY}"

curl --fail-with-body -sS https://makefav.com/api/v1/generate \
  -H "Authorization: Bearer $MAKEFAV_API_KEY" \
  -F "[email protected]" \
  -F "app_name=My App" \
  -F "theme_color=#2f9e68" \
  -F "radius=20" \
  -o favicons.zip || { cat favicons.zip; rm -f favicons.zip; exit 1; }

unzip -o -q favicons.zip -d public/
rm favicons.zip
echo "Favicons written to public/"