Create Artifact

curl -X POST https://genui.sh/api/artifacts \
  -H "Authorization: Bearer $GENUI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "template": "markdown",
    "title": "My Document",
    "content": {"text": "# Hello World\n\nThis is my artifact."},
    "expiresIn": "7d"
  }'

import requests
import os

response = requests.post(
    "https://genui.sh/api/artifacts",
    headers={"Authorization": f"Bearer {os.environ['GENUI_API_KEY']}"},
    json={
        "template": "markdown",
        "title": "My Document",
        "content": {"text": "# Hello World\n\nThis is my artifact."},
        "expiresIn": "7d"
    }
)
artifact = response.json()
print(f"Created artifact: {artifact['id']}")

const response = await fetch('https://genui.sh/api/artifacts', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.GENUI_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    template: 'markdown',
    title: 'My Document',
    content: { text: '# Hello World\n\nThis is my artifact.' },
    expiresIn: '7d'
  })
});
const artifact = await response.json();
console.log(`Created artifact: ${artifact.id}`);

package main

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

func main() {
    payload := map[string]interface{}{
        "template":  "markdown",
        "title":     "My Document",
        "content":   map[string]string{"text": "# Hello World\n\nThis is my artifact."},
        "expiresIn": "7d",
    }
    body, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://genui.sh/api/artifacts", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("GENUI_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("Created artifact: %s\n", result["id"])
}

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

uri = URI('https://genui.sh/api/artifacts')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = "Bearer #{ENV['GENUI_API_KEY']}"
request['Content-Type'] = 'application/json'
request.body = {
  template: 'markdown',
  title: 'My Document',
  content: { text: '# Hello World\n\nThis is my artifact.' },
  expiresIn: '7d'
}.to_json

response = http.request(request)
artifact = JSON.parse(response.body)
puts "Created artifact: #{artifact['id']}"

use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
use serde_json::json;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("GENUI_API_KEY")?;
    let client = reqwest::Client::new();

    let response = client
        .post("https://genui.sh/api/artifacts")
        .header(AUTHORIZATION, format!("Bearer {}", api_key))
        .header(CONTENT_TYPE, "application/json")
        .json(&json!({
            "template": "markdown",
            "title": "My Document",
            "content": {"text": "# Hello World\n\nThis is my artifact."},
            "expiresIn": "7d"
        }))
        .send()
        .await?;

    let artifact: serde_json::Value = response.json().await?;
    println!("Created artifact: {}", artifact["id"]);
    Ok(())
}

using System.Net.Http.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {Environment.GetEnvironmentVariable("GENUI_API_KEY")}");

var response = await client.PostAsJsonAsync("https://genui.sh/api/artifacts", new {
    template = "markdown",
    title = "My Document",
    content = new { text = "# Hello World\n\nThis is my artifact." },
    expiresIn = "7d"
});

var artifact = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine($"Created artifact: {artifact.GetProperty("id")}");