Choose a Video Generation Model

1
const response = await fetch("https://openrouter.ai/api/v1/videos/models");
2
3
if (!response.ok) {
4
  throw new Error(await response.text());
5
}
6
7
const { data } = await response.json();
8
const models = data;
9
10
console.log(models.map((model) => model.id));

1
function findVideoModels(models) {
2
  return models.filter((model) => {
3
    const supportsRequest =
4
      model.supported_resolutions?.includes("720p") &&
5
      model.supported_aspect_ratios?.includes("9:16") &&
6
      model.supported_durations?.includes(5) &&
7
      model.supported_frame_images?.includes("first_frame");
8
9
    return supportsRequest;
10
  });
11
}
12
13
function getLowestAdvertisedPrice(model) {
14
  const prices = Object.values(model.pricing_skus ?? {})
15
    .map((price) => Number(price))
16
    .filter((price) => Number.isFinite(price));
17
18
  return prices.length > 0 ? Math.min(...prices) : Number.POSITIVE_INFINITY;
19
}
20
21
const matchingModels = findVideoModels(models).sort((first, second) => {
22
  return getLowestAdvertisedPrice(first) - getLowestAdvertisedPrice(second);
23
});
24
25
if (matchingModels.length === 0) {
26
  throw new Error("No matching video model found.");
27
}
28
29
console.log(
30
  JSON.stringify(
31
    matchingModels.map((match) => ({
32
      id: match.id,
33
      lowest_advertised_price: getLowestAdvertisedPrice(match),
34
    })),
35
    null,
36
    2,
37
  ),
38
);

1
const priorityProfiles = {
2
  fastAndCheap: {
3
    speed: 0.55,
4
    cost: 0.35,
5
    quality: 0.1,
6
  },
7
  qualityAndCost: {
8
    speed: 0.15,
9
    cost: 0.3,
10
    quality: 0.55,
11
  },
12
  balanced: {
13
    speed: 0.33,
14
    cost: 0.33,
15
    quality: 0.34,
16
  },
17
};
18
19
const resolutionRanks = new Map([
20
  ["480p", 1],
21
  ["720p", 2],
22
  ["1080p", 3],
23
  ["4K", 4],
24
]);
25
26
function getResolutionRank(model) {
27
  return Math.max(
28
    0,
29
    ...(model.supported_resolutions ?? []).map((resolution) => {
30
      return resolutionRanks.get(resolution) ?? 0;
31
    }),
32
  );
33
}
34
35
function getSpeedScore(model) {
36
  const id = model.id.toLowerCase();
37
38
  if (id.includes("fast")) return 1;
39
  if (id.includes("lite") || id.includes("std")) return 0.8;
40
  if (id.includes("pro") || id.includes("o1")) return 0.35;
41
42
  return 0.55;
43
}
44
45
function normalize(value, min, max, invert = false) {
46
  if (!Number.isFinite(value) || max === min) {
47
    return 0.5;
48
  }
49
50
  const score = (value - min) / (max - min);
51
52
  return invert ? 1 - score : score;
53
}
54
55
function scoreVideoModels(models, weights) {
56
  const prices = models.map(getLowestAdvertisedPrice).filter(Number.isFinite);
57
  const minPrice = prices.length > 0 ? Math.min(...prices) : 0;
58
  const maxPrice = prices.length > 0 ? Math.max(...prices) : 0;
59
  const maxResolutionRank = Math.max(0, ...models.map(getResolutionRank));
60
61
  return models
62
    .map((model) => {
63
      const price = getLowestAdvertisedPrice(model);
64
      const speedScore = getSpeedScore(model);
65
      const costScore = Number.isFinite(price)
66
        ? normalize(price, minPrice, maxPrice, true)
67
        : 0;
68
      const qualityScore =
69
        maxResolutionRank === 0 ? 0.5 : getResolutionRank(model) / maxResolutionRank;
70
      const score =
71
        weights.speed * speedScore +
72
        weights.cost * costScore +
73
        weights.quality * qualityScore;
74
75
      return {
76
        model,
77
        id: model.id,
78
        score: Number(score.toFixed(3)),
79
        lowest_advertised_price: price,
80
        speed_score: Number(speedScore.toFixed(3)),
81
        cost_score: Number(costScore.toFixed(3)),
82
        quality_score: Number(qualityScore.toFixed(3)),
83
      };
84
    })
85
    .sort((first, second) => second.score - first.score);
86
}
87
88
function summarizeScores(rankedModels) {
89
  return rankedModels.slice(0, 4).map(({ model: _model, ...summary }) => {
90
    return summary;
91
  });
92
}
93
94
const fastAndCheapModels = scoreVideoModels(
95
  matchingModels,
96
  priorityProfiles.fastAndCheap,
97
);
98
const qualityAndCostModels = scoreVideoModels(
99
  matchingModels,
100
  priorityProfiles.qualityAndCost,
101
);
102
const model = fastAndCheapModels[0]?.model;
103
104
if (!model) {
105
  throw new Error("No scored video model found.");
106
}
107
108
console.log(
109
  JSON.stringify(
110
    {
111
      fast_and_cheap: summarizeScores(fastAndCheapModels),
112
      quality_and_cost: summarizeScores(qualityAndCostModels),
113
    },
114
    null,
115
    2,
116
  ),
117
);
118
console.log(`Use ${model.id}`);

1
const firstFrameUrl = process.env.FIRST_FRAME_URL;
2
3
if (!firstFrameUrl) {
4
  throw new Error("Set FIRST_FRAME_URL to a directly downloadable image URL.");
5
}
6
7
const requestBody = {
8
  model: model.id,
9
  prompt:
10
    "A handheld vertical product shot of a ceramic mug on a sunny kitchen counter",
11
  duration: 5,
12
  resolution: "720p",
13
  aspect_ratio: "9:16",
14
  frame_images: [
15
    {
16
      type: "image_url",
17
      image_url: {
18
        url: firstFrameUrl,
19
      },
20
      frame_type: "first_frame",
21
    },
22
  ],
23
};
24
25
console.log(JSON.stringify(requestBody, null, 2));

1
const apiKey = process.env.OPENROUTER_API_KEY;
2
3
if (!apiKey) {
4
  throw new Error("Set OPENROUTER_API_KEY before submitting a video job.");
5
}
6
7
const generation = await fetch("https://openrouter.ai/api/v1/videos", {
8
  method: "POST",
9
  headers: {
10
    Authorization: `Bearer ${apiKey}`,
11
    "Content-Type": "application/json",
12
  },
13
  body: JSON.stringify(requestBody),
14
});
15
16
if (!generation.ok) {
17
  throw new Error(await generation.text());
18
}
19
20
console.log(await generation.json());