# pip install requests
import requests

API_KEY = "YOUR_API_KEY"
TARGET  = "https://carts.target.com/web_checkouts/v1/cart_items"

r = requests.post(
    "https://shape.atlas.example.com/v1/sign",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"method": "POST", "url": TARGET},
    timeout=10,
)
r.raise_for_status()
data = r.json()
shape, build, ua = data["headers"], data["build"], data["user_agent"]

# Forward Shape headers + the matching User-Agent to the target.
forward = {
    "User-Agent": ua,
    "Content-Type": "application/json",
    **{f"X-{build}-{k.split('-')[-1]}": v for k, v in shape.items()},
}
res = requests.post(TARGET, headers=forward, data='{"cart_item":{}}')
print(res.status_code, res.text[:200])

// node 20+ (built-in fetch)
const API_KEY = "YOUR_API_KEY";
const TARGET  = "https://carts.target.com/web_checkouts/v1/cart_items";

const signRes = await fetch("https://shape.atlas.example.com/v1/sign", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ method: "POST", url: TARGET }),
});
if (!signRes.ok) throw new Error(`sign failed: ${signRes.status}`);
const { headers: shape, build, user_agent } = await signRes.json();

const forward = {
  "User-Agent": user_agent,
  "Content-Type": "application/json",
  ...Object.fromEntries(
    Object.entries(shape).map(([k, v]) => [`X-${build}-${k.split("-").pop()}`, v]),
  ),
};
const res = await fetch(TARGET, { method: "POST", headers: forward, body: '{"cart_item":{}}' });
console.log(res.status, await res.text());

// node 20+ — `npm i -D typescript @types/node` then `tsc`.
interface SignResponse {
  headers: Record<string, string>;
  build: string;
  user_agent: string;
}

const API_KEY: string = "YOUR_API_KEY";
const TARGET:  string = "https://carts.target.com/web_checkouts/v1/cart_items";

async function sign(url: string, method: string = "GET"): Promise<SignResponse> {
  const r = await fetch("https://shape.atlas.example.com/v1/sign", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ url, method }),
  });
  if (!r.ok) throw new Error(`sign ${r.status}`);
  return r.json() as Promise<SignResponse>;
}

const { headers: shape, build, user_agent } = await sign(TARGET, "POST");
const res = await fetch(TARGET, {
  method: "POST",
  headers: { "User-Agent": user_agent, "Content-Type": "application/json", ...shape },
  body: '{"cart_item":{}}',
});
console.log(res.status);

// go.mod: module example.com/atlas-shape
package main

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

type SignResponse struct {
    Headers   map[string]string `json:"headers"`
    Build     string            `json:"build"`
    UserAgent string            `json:"user_agent"`
}

func main() {
    apiKey := "YOUR_API_KEY"
    target := "https://carts.target.com/web_checkouts/v1/cart_items"

    body, _ := json.Marshal(map[string]string{"method": "POST", "url": target})
    req, _ := http.NewRequest("POST", "https://shape.atlas.example.com/v1/sign", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    res, err := http.DefaultClient.Do(req)
    if err != nil { panic(err) }
    defer res.Body.Close()

    var sr SignResponse
    json.NewDecoder(res.Body).Decode(&sr)

    fwd, _ := http.NewRequest("POST", target, bytes.NewBufferString(`{"cart_item":{}}`))
    fwd.Header.Set("User-Agent", sr.UserAgent)
    fwd.Header.Set("Content-Type", "application/json")
    for k, v := range sr.Headers {
        fwd.Header.Set(k, v)
    }
    out, _ := http.DefaultClient.Do(fwd)
    defer out.Body.Close()
    raw, _ := io.ReadAll(out.Body)
    fmt.Println(out.StatusCode, string(raw))
}

// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }, tokio = { version = "1", features = ["full"] }, serde = { version = "1", features = ["derive"] }
use serde::Deserialize;
use std::collections::HashMap;

#[derive(Deserialize)]
struct SignResponse {
    headers: HashMap<String, String>,
    build: String,
    user_agent: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = "YOUR_API_KEY";
    let target  = "https://carts.target.com/web_checkouts/v1/cart_items";

    let client = reqwest::Client::new();
    let sr: SignResponse = client
        .post("https://shape.atlas.example.com/v1/sign")
        .bearer_auth(api_key)
        .json(&serde_json::json!({ "method": "POST", "url": target }))
        .send().await?
        .error_for_status()?
        .json().await?;

    let mut req = client.post(target)
        .header("User-Agent", &sr.user_agent)
        .header("Content-Type", "application/json")
        .body(r#"{"cart_item":{}}"#);
    for (k, v) in &sr.headers { req = req.header(k, v); }
    let res = req.send().await?;
    println!("{} {}", res.status(), res.text().await?);
    Ok(())
}