@storylinkpro/instagram-stories-api 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.1
+
+- The package description, keywords and README make the package easier to find.
+- A GitHub Actions workflow publishes new versions with npm provenance.
+
+## 0.1.0
+
+- First release. A typed client and CLI that read an Instagram account, its Stories, posts and reels, and their insights.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Storylink
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,149 @@
-# Temporary Holding Version
+# @storylinkpro/instagram-stories-api
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/@storylinkpro/instagram-stories-api)](https://www.npmjs.com/package/@storylinkpro/instagram-stories-api)
+[![CI](https://github.com/storylinkpro/instagram-stories-api/actions/workflows/ci.yml/badge.svg)](https://github.com/storylinkpro/instagram-stories-api/actions/workflows/ci.yml)
+[![types](https://img.shields.io/npm/types/@storylinkpro/instagram-stories-api)](https://www.npmjs.com/package/@storylinkpro/instagram-stories-api)
+[![license](https://img.shields.io/npm/l/@storylinkpro/instagram-stories-api)](LICENSE)
+
+**An Instagram Graph API client and CLI for Node.js and TypeScript.** It reads Instagram Stories, posts and reels. It also reads their insights: views, reach, replies, likes, comments, saves and shares. It has no dependencies. It needs Node 20+ or another runtime with `fetch`.
+
+Use it in a script, a cron job or your own Instagram analytics dashboard.
+
+> Unofficial. Meta did not make this package and does not support it. It calls Meta's public Graph API at `graph.facebook.com`.
+
+## Install
+
+```sh
+npm install @storylinkpro/instagram-stories-api
+```
+
+## Quick start: read Instagram story insights
+
+```ts
+import { createClient } from "@storylinkpro/instagram-stories-api";
+
+const ig = createClient({
+  accessToken: process.env.INSTAGRAM_ACCESS_TOKEN!,
+  igUserId: process.env.INSTAGRAM_USER_ID, // the Instagram professional account id
+});
+
+const { username, followers_count } = await ig.account();
+
+for (const story of await ig.stories()) {
+  const { views, reach, replies } = await ig.storyInsights(story.id);
+  console.log(story.id, views, reach, replies);
+}
+```
+
+## Command line
+
+You can query the API from a terminal without an install:
+
+```sh
+npx @storylinkpro/instagram-stories-api stories
+```
+
+After `npm install -g @storylinkpro/instagram-stories-api`, the command is `instagram-stories-api`.
+
+```text
+ID                 TYPE   POSTED (UTC)      PERMALINK
+18012345678901234  IMAGE  2026-11-07 08:30  https://www.instagram.com/stories/example/18012345678901234
+18012345678905678  VIDEO  2026-11-07 09:10  https://www.instagram.com/stories/example/18012345678905678
+```
+
+| Command | Prints |
+|---|---|
+| `account` | The account's id, username, name, followers, follows and media count. |
+| `stories` | The account's current stories. Instagram keeps a story for 24 hours. |
+| `media [--limit n]` | The most recent posts and reels. The default is 10. |
+| `insights <media-id> [--type story\|post\|reel]` | Insights for one media. The default type is `story`. |
+| `account-insights [--since 7d]` | Account totals for a window: views, reach, likes, comments, shares and replies. |
+
+Options:
+
+- `--token`: the access token. The default is `INSTAGRAM_ACCESS_TOKEN`.
+- `--account`, `-a`: the Instagram account id. The default is `INSTAGRAM_USER_ID`.
+- `--since`, `-s` and `--until`, `-u`: `24h`, `7d`, `30d` or a date such as `2026-10-01`. Meta rejects a window of 30 days or more.
+- `--metrics`: account metrics, separated by commas.
+- `--api-version`: the Graph API version. The default is `v25.0`.
+- `--json`: print JSON for a script or another tool.
+- `--help`, `-h`: help for the CLI or for one command.
+
+The CLI never prints the token. The exit code is 0 on success, 1 when Meta returns an error, and 2 for a usage error.
+
+## Methods
+
+| Method | Returns |
+|---|---|
+| `account()` | `{ id, username, name, followers_count, follows_count, media_count, profile_picture_url }`. |
+| `stories()` | The current stories as `Media[]`. It reads every page. |
+| `media({ limit?, since?, until?, after? })` | One page of posts and reels: `{ data, after, hasNext }`. Pass `after` to get the next page. |
+| `iterateMedia({ ..., max? })` | An async iterator over all posts and reels. It follows `paging.next`. `max` stops it early. |
+| `storyInsights(mediaId)` | `{ views, reach, replies, shares }`. |
+| `postInsights(mediaId)` | `{ views, reach, likes, comments, saves, shares }`. |
+| `reelInsights(mediaId)` | `{ views, reach, likes, comments, saves, shares }`. |
+| `accountInsights({ metrics?, since?, until?, period?, metricType?, breakdown?, timeframe? })` | One `{ name, period, total, values, breakdowns }` per metric. |
+
+A `Media` has `id`, `media_type`, `media_product_type`, `timestamp`, `permalink`, `caption`, `media_url` and `thumbnail_url`. A field that Meta leaves out is `null`.
+
+An insight that Meta does not return is `null`, not `0`. Meta withholds some story numbers when fewer than 5 people saw the story. Meta calls saves `saved`. The client returns them as `saves`.
+
+`accountInsights()` sends `period=day` and `metric_type=total_value` by default. For follower demographics, pass `metrics: ["follower_demographics"]`, `period: "lifetime"`, `timeframe: "this_month"` and a `breakdown` such as `"country"` or `"age,gender"`.
+
+`since` and `until` take a `Date`, epoch milliseconds or a date string. The client sends Unix seconds.
+
+Methods that read an account take `igUserId` to use another account than the client's. Every method takes `signal` (an `AbortSignal`).
+
+`createClient()` also takes `apiVersion` (default `v25.0`), `fetch` (for tests or another runtime) and `timeoutMs` (default 30000).
+
+## Errors
+
+A failed call throws `InstagramApiError`. It has `status`, and Meta's `code`, `subcode`, `type`, `fbtraceId` and `message`. It also has these flags:
+
+- `isAuthError`: code 190, or subcode 458, 460, 463 or 467. The token expired, someone revoked it, or it is not valid. Get a new token.
+- `isRateLimit`: code 4, 17, 32, 613, 80001 or 80002. Meta throttled the app or the account. Wait before you try again.
+
+A network error or a timeout has `status` 0. The message never contains the access token.
+
+```ts
+import { InstagramApiError } from "@storylinkpro/instagram-stories-api";
+
+try {
+  await ig.stories();
+} catch (e) {
+  if (e instanceof InstagramApiError && e.isAuthError) console.error("Get a new token");
+  else throw e;
+}
+```
+
+### Instagram API rate limits
+
+Meta sends usage headers on each response. `ig.lastUsage` holds the most recent ones, and `error.usage` holds the ones of a failed call:
+
+```ts
+ig.lastUsage?.app; // { call_count, total_time, total_cputime } from x-app-usage, in percent
+ig.lastUsage?.businessUseCase; // from x-business-use-case-usage, per business object id
+```
+
+The client does not retry. You decide when to call again.
+
+## Get an Instagram Graph API access token
+
+This version uses the Instagram API with Facebook Login. You need:
+
+1. An Instagram professional account (Business or Creator) that is linked to a Facebook Page.
+2. A Meta app with the `instagram_basic`, `instagram_manage_insights` and `pages_read_engagement` permissions.
+3. A Facebook User or Page access token. For a quick test, get one in the [Graph API Explorer](https://developers.facebook.com/tools/explorer/).
+
+To find the Instagram account id, call `GET /me/accounts?fields=instagram_business_account` with the token. See Meta's [Instagram Platform docs](https://developers.facebook.com/docs/instagram-platform) for the full steps.
+
+Keep the token on the server. Do not send it to the browser.
+
+## Related
+
+- [Storylink](https://storylink.pro) schedules Instagram Stories, posts and reels, and shows their results. Storylink made this package.
+- [`storylink-mcp`](https://www.npmjs.com/package/storylink-mcp) connects Claude and other AI assistants to your Storylink Instagram analytics.
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { run } from "./cli.js";
+const code = await run(process.argv.slice(2), {
+    env: process.env,
+    stdout: (s) => process.stdout.write(s),
+    stderr: (s) => process.stderr.write(s),
+});
+process.exitCode = code;

package/dist/cli.d.ts

@@ -0,0 +1,15 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_API_ERROR = 1;
+export declare const EXIT_USAGE = 2;
+export type CliIo = {
+    env: Record<string, string | undefined>;
+    stdout: (text: string) => void;
+    stderr: (text: string) => void;
+    fetch?: typeof fetch;
+    now?: () => Date;
+};
+/** Parse `7d`, `24h` or a date string into a Date. */
+export declare function parseWhen(value: string, now: Date): Date;
+/** Render rows as a plain text table. Number columns are right-aligned. */
+export declare function table(headers: string[], rows: Array<Array<string | number | null>>, numeric?: boolean[]): string;
+export declare function run(argv: string[], io: CliIo): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,246 @@
+import { parseArgs } from "node:util";
+import { createClient } from "./client.js";
+import { InstagramApiError, redact } from "./errors.js";
+export const EXIT_OK = 0;
+export const EXIT_API_ERROR = 1;
+export const EXIT_USAGE = 2;
+class UsageError extends Error {
+}
+const COMMANDS = ["account", "stories", "media", "insights", "account-insights"];
+const GLOBAL_HELP = `Usage: instagram-stories-api <command> [options]
+
+Read Instagram Stories, media and insights from the Instagram Graph API.
+
+Commands:
+  account                     Show the account's profile and counts.
+  stories                     List the account's current stories (last 24 hours).
+  media [--limit n]           List recent posts and reels. Default 10.
+  insights <media-id>         Show insights for one media. Add --type story|post|reel.
+  account-insights            Show account insights. Add --since 7d|30d|YYYY-MM-DD.
+
+Options:
+  --token <token>             Access token. Default: $INSTAGRAM_ACCESS_TOKEN.
+  --account, -a <id>          Instagram account id. Default: $INSTAGRAM_USER_ID.
+  --api-version <v>           Graph API version. Default: v25.0.
+  --json                      Print JSON.
+  --help, -h                  Show help. "<command> --help" shows help for one command.
+
+Exit codes: 0 success, 1 API error, 2 usage error.
+Unofficial. Not made or supported by Meta. Made by Storylink: https://storylink.pro`;
+const COMMAND_HELP = {
+    account: `Usage: instagram-stories-api account [--account <id>] [--json]
+
+Show the account's id, username, name, followers, follows and media count.`,
+    stories: `Usage: instagram-stories-api stories [--account <id>] [--json]
+
+List the account's current stories. Instagram keeps a story for 24 hours.`,
+    media: `Usage: instagram-stories-api media [--limit n] [--account <id>] [--json]
+
+List the account's most recent posts and reels, newest first.
+
+  --limit, -n <n>   The number of items. Default 10.`,
+    insights: `Usage: instagram-stories-api insights <media-id> [--type story|post|reel] [--json]
+
+Show insights for one media.
+
+  --type, -t <type>   story (default): views, reach, replies, shares.
+                      post or reel: views, reach, likes, comments, saves, shares.`,
+    "account-insights": `Usage: instagram-stories-api account-insights [--since 7d] [--until <date>] [--metrics a,b] [--json]
+
+Show account totals for a time window.
+
+  --since, -s <when>   24h, 7d, 30d or a date such as 2026-10-01. Default 7d.
+  --until, -u <when>   The end of the window. Default now.
+  --metrics <list>     Comma-separated metrics. Default views,reach,likes,comments,shares,replies.
+
+Meta rejects a window of 30 days or more.`,
+};
+/** Parse `7d`, `24h` or a date string into a Date. */
+export function parseWhen(value, now) {
+    const rel = /^(\d+)([dh])$/.exec(value);
+    if (rel) {
+        const n = Number(rel[1]);
+        const ms = rel[2] === "d" ? n * 86_400_000 : n * 3_600_000;
+        return new Date(now.getTime() - ms);
+    }
+    if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+        const t = Date.parse(value);
+        if (Number.isFinite(t))
+            return new Date(t);
+    }
+    throw new UsageError(`Not a valid time: "${value}". Use 24h, 7d, 30d or YYYY-MM-DD.`);
+}
+const fmtNum = (n) => typeof n === "number" ? n.toLocaleString("en-US") : "-";
+/** Render rows as a plain text table. Number columns are right-aligned. */
+export function table(headers, rows, numeric = []) {
+    const cells = rows.map((r) => r.map((c) => (typeof c === "number" ? fmtNum(c) : c ?? "-")));
+    const widths = headers.map((h, i) => Math.max(h.length, ...cells.map((r) => (r[i] ?? "").length)));
+    const line = (r) => r
+        .map((c, i) => (numeric[i] ? c.padStart(widths[i]) : c.padEnd(widths[i])))
+        .join("  ")
+        .trimEnd();
+    return [line(headers), ...cells.map(line)].join("\n");
+}
+function shortTime(iso) {
+    return iso ? iso.replace("T", " ").replace(/:\d{2}(\+0000|Z)$/, "").slice(0, 16) : "-";
+}
+function oneLine(text, max = 40) {
+    if (!text)
+        return "-";
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+export async function run(argv, io) {
+    let token;
+    const out = (s) => io.stdout(redact(s, token) + "\n");
+    const err = (s) => io.stderr(redact(s, token) + "\n");
+    try {
+        let parsed;
+        try {
+            parsed = parseArgs({
+                args: argv,
+                allowPositionals: true,
+                strict: true,
+                options: {
+                    token: { type: "string" },
+                    account: { type: "string", short: "a" },
+                    "api-version": { type: "string" },
+                    json: { type: "boolean" },
+                    help: { type: "boolean", short: "h" },
+                    limit: { type: "string", short: "n" },
+                    type: { type: "string", short: "t" },
+                    since: { type: "string", short: "s" },
+                    until: { type: "string", short: "u" },
+                    metrics: { type: "string" },
+                },
+            });
+        }
+        catch (e) {
+            throw new UsageError(e instanceof Error ? e.message : String(e));
+        }
+        const { values, positionals } = parsed;
+        token = values.token ?? io.env.INSTAGRAM_ACCESS_TOKEN;
+        const [cmdName, ...rest] = positionals;
+        if (!cmdName) {
+            (values.help ? out : err)(GLOBAL_HELP);
+            return values.help ? EXIT_OK : EXIT_USAGE;
+        }
+        if (!COMMANDS.includes(cmdName)) {
+            throw new UsageError(`Unknown command "${cmdName}". Run "instagram-stories-api --help".`);
+        }
+        const cmd = cmdName;
+        if (values.help) {
+            out(COMMAND_HELP[cmd]);
+            return EXIT_OK;
+        }
+        const maxPositionals = cmd === "insights" ? 1 : 0;
+        if (rest.length > maxPositionals)
+            throw new UsageError(`Unexpected argument "${rest[maxPositionals]}".`);
+        if (!token)
+            throw new UsageError("No access token. Pass --token or set INSTAGRAM_ACCESS_TOKEN.");
+        const igUserId = values.account ?? io.env.INSTAGRAM_USER_ID;
+        if (cmd !== "insights" && !igUserId) {
+            throw new UsageError("No account id. Pass --account or set INSTAGRAM_USER_ID.");
+        }
+        let client;
+        try {
+            client = createClient({
+                accessToken: token,
+                igUserId,
+                apiVersion: values["api-version"],
+                fetch: io.fetch,
+            });
+        }
+        catch (e) {
+            throw new UsageError(e instanceof Error ? e.message : String(e));
+        }
+        const json = values.json === true;
+        const print = (data, text) => out(json ? JSON.stringify(data, null, 2) : text());
+        const now = io.now?.() ?? new Date();
+        switch (cmd) {
+            case "account": {
+                const a = await client.account();
+                print(a, () => table(["FIELD", "VALUE"], [
+                    ["id", a.id],
+                    ["username", a.username],
+                    ["name", a.name],
+                    ["followers", fmtNum(a.followers_count)],
+                    ["follows", fmtNum(a.follows_count)],
+                    ["media", fmtNum(a.media_count)],
+                ]));
+                return EXIT_OK;
+            }
+            case "stories": {
+                const s = await client.stories();
+                print(s, () => s.length === 0
+                    ? "No current stories."
+                    : table(["ID", "TYPE", "POSTED (UTC)", "PERMALINK"], s.map((m) => [m.id, m.media_type, shortTime(m.timestamp), m.permalink])));
+                return EXIT_OK;
+            }
+            case "media": {
+                const limit = values.limit === undefined ? 10 : Number(values.limit);
+                if (!Number.isInteger(limit) || limit < 1)
+                    throw new UsageError("--limit must be a positive whole number.");
+                const items = [];
+                for await (const m of client.iterateMedia({ max: limit, limit: Math.min(limit, 50) }))
+                    items.push(m);
+                print(items, () => items.length === 0
+                    ? "No media."
+                    : table(["ID", "KIND", "POSTED (UTC)", "CAPTION"], items.map((m) => [m.id, m.media_product_type ?? m.media_type, shortTime(m.timestamp), oneLine(m.caption)])));
+                return EXIT_OK;
+            }
+            case "insights": {
+                const mediaId = rest[0];
+                if (!mediaId)
+                    throw new UsageError("Missing <media-id>. Usage: instagram-stories-api insights <media-id>");
+                if (!/^[A-Za-z0-9_]+$/.test(mediaId))
+                    throw new UsageError("<media-id> must contain only letters, digits or \"_\".");
+                const type = values.type ?? "story";
+                let result;
+                if (type === "story")
+                    result = await client.storyInsights(mediaId);
+                else if (type === "post")
+                    result = await client.postInsights(mediaId);
+                else if (type === "reel")
+                    result = await client.reelInsights(mediaId);
+                else
+                    throw new UsageError(`--type must be story, post or reel, not "${type}".`);
+                print(result, () => table(["METRIC", "VALUE"], Object.entries(result).map(([k, v]) => [k, v]), [false, true]));
+                return EXIT_OK;
+            }
+            case "account-insights": {
+                const since = parseWhen(values.since ?? "7d", now);
+                const until = values.until ? parseWhen(values.until, now) : now;
+                if (since >= until)
+                    throw new UsageError("--since must be before --until.");
+                const metrics = values.metrics
+                    ?.split(",")
+                    .map((m) => m.trim())
+                    .filter(Boolean);
+                if (metrics && metrics.length === 0)
+                    throw new UsageError("--metrics must name at least one metric.");
+                const rows = await client.accountInsights({ since, until, metrics });
+                print(rows, () => table(["METRIC", "TOTAL"], rows.map((r) => [r.name, r.total]), [false, true]));
+                return EXIT_OK;
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof UsageError || e instanceof TypeError) {
+            err(`Error: ${e.message}`);
+            return EXIT_USAGE;
+        }
+        if (e instanceof InstagramApiError) {
+            err(`Error: ${e.message}`);
+            if (e.isAuthError)
+                err("The access token is expired or not valid. Get a new token.");
+            else if (e.isRateLimit)
+                err("Meta rate-limited this app or account. Wait and try again.");
+            if (e.fbtraceId)
+                err(`fbtrace_id: ${e.fbtraceId}`);
+            return EXIT_API_ERROR;
+        }
+        err(`Error: ${e instanceof Error ? e.message : String(e)}`);
+        return EXIT_API_ERROR;
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,144 @@
+import { type TimeInput } from "./time.js";
+import { type RateLimitUsage } from "./usage.js";
+export declare const DEFAULT_API_VERSION = "v25.0";
+export declare const GRAPH_HOST = "https://graph.facebook.com";
+/** Fields read for every media object (stories, posts and reels). */
+export declare const MEDIA_FIELDS: readonly ["id", "media_type", "media_product_type", "timestamp", "permalink", "caption", "media_url", "thumbnail_url"];
+/** Fields read by `account()`. */
+export declare const ACCOUNT_FIELDS: readonly ["id", "username", "name", "followers_count", "follows_count", "media_count", "profile_picture_url"];
+/** Metrics requested by `storyInsights()`. */
+export declare const STORY_METRICS: readonly ["views", "reach", "replies", "shares"];
+/** Metrics requested by `postInsights()`. Meta calls saves `saved`. */
+export declare const POST_METRICS: readonly ["views", "reach", "likes", "comments", "saved", "shares"];
+/** Metrics requested by `reelInsights()`. Meta calls saves `saved`. */
+export declare const REEL_METRICS: readonly ["views", "reach", "likes", "comments", "saved", "shares"];
+/** Default metrics for `accountInsights()`. */
+export declare const DEFAULT_ACCOUNT_METRICS: readonly ["views", "reach", "likes", "comments", "shares", "replies"];
+export type ClientOptions = {
+    /** A Facebook User or Page access token with Instagram permissions. */
+    accessToken: string;
+    /** The Instagram professional account id. Methods can also take it per call. */
+    igUserId?: string;
+    /** Graph API version. Default `v25.0`. */
+    apiVersion?: string;
+    /** A `fetch` implementation. Default: the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Abort a request after this many milliseconds. Default 30000. */
+    timeoutMs?: number;
+};
+export type CallOptions = {
+    /** Use this account instead of the client's `igUserId`. */
+    igUserId?: string;
+    signal?: AbortSignal;
+};
+export type Account = {
+    id: string;
+    username: string | null;
+    name: string | null;
+    followers_count: number | null;
+    follows_count: number | null;
+    media_count: number | null;
+    profile_picture_url: string | null;
+};
+export type MediaType = "IMAGE" | "VIDEO" | "CAROUSEL_ALBUM" | (string & {});
+export type MediaProductType = "FEED" | "REELS" | "STORY" | "AD" | (string & {});
+export type Media = {
+    id: string;
+    media_type: MediaType | null;
+    media_product_type: MediaProductType | null;
+    /** ISO 8601 time the media was published. */
+    timestamp: string | null;
+    permalink: string | null;
+    caption: string | null;
+    /** Meta leaves this out for some videos (for example, ones with licensed audio). */
+    media_url: string | null;
+    thumbnail_url: string | null;
+};
+export type MediaOptions = CallOptions & {
+    /** Items per page. Meta's default is 25. */
+    limit?: number;
+    since?: TimeInput;
+    until?: TimeInput;
+    /** A cursor from a previous page's `after`. */
+    after?: string;
+};
+export type MediaPage = {
+    data: Media[];
+    /** Cursor for the next page, or null on the last page. */
+    after: string | null;
+    /** True when Meta says there is another page. */
+    hasNext: boolean;
+};
+export type StoryInsights = {
+    views: number | null;
+    reach: number | null;
+    replies: number | null;
+    shares: number | null;
+};
+export type PostInsights = {
+    views: number | null;
+    reach: number | null;
+    likes: number | null;
+    comments: number | null;
+    saves: number | null;
+    shares: number | null;
+};
+export type ReelInsights = PostInsights;
+export type AccountInsightsOptions = CallOptions & {
+    /** Metric names. Default: views, reach, likes, comments, shares, replies. */
+    metrics?: readonly string[];
+    /** Default `day`. Demographic metrics use `lifetime`. */
+    period?: string;
+    /** Default `total_value`. Pass `null` to leave it out. */
+    metricType?: "total_value" | "time_series" | null;
+    since?: TimeInput;
+    until?: TimeInput;
+    /** For example `media_product_type`, or `age,gender` for demographics. */
+    breakdown?: string;
+    /** For demographic metrics, for example `this_month`. */
+    timeframe?: string;
+};
+export type AccountInsightBreakdown = {
+    dimensionKeys: string[];
+    results: Array<{
+        dimensionValues: string[];
+        value: number;
+    }>;
+};
+export type AccountInsight = {
+    name: string;
+    period: string | null;
+    title: string | null;
+    description: string | null;
+    /** `total_value.value` when the metric has one, otherwise null. */
+    total: number | null;
+    /** Values per period, for `time_series` metrics. */
+    values: Array<{
+        value: unknown;
+        endTime: string | null;
+    }>;
+    breakdowns: AccountInsightBreakdown[];
+};
+export type InstagramClient = {
+    readonly apiVersion: string;
+    readonly baseUrl: string;
+    /** Usage headers from the most recent response, or null before the first call. */
+    readonly lastUsage: RateLimitUsage | null;
+    account(options?: CallOptions): Promise<Account>;
+    stories(options?: CallOptions): Promise<Media[]>;
+    media(options?: MediaOptions): Promise<MediaPage>;
+    iterateMedia(options?: MediaOptions & {
+        max?: number;
+    }): AsyncGenerator<Media, void, undefined>;
+    storyInsights(mediaId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<StoryInsights>;
+    postInsights(mediaId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<PostInsights>;
+    reelInsights(mediaId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ReelInsights>;
+    accountInsights(options?: AccountInsightsOptions): Promise<AccountInsight[]>;
+};
+export declare function createClient(options: ClientOptions): InstagramClient;

package/dist/client.js

@@ -0,0 +1,300 @@
+import { InstagramApiError, redact } from "./errors.js";
+import { toUnixSeconds } from "./time.js";
+import { parseUsageHeaders } from "./usage.js";
+export const DEFAULT_API_VERSION = "v25.0";
+export const GRAPH_HOST = "https://graph.facebook.com";
+const DEFAULT_TIMEOUT_MS = 30_000;
+/** Fields read for every media object (stories, posts and reels). */
+export const MEDIA_FIELDS = [
+    "id",
+    "media_type",
+    "media_product_type",
+    "timestamp",
+    "permalink",
+    "caption",
+    "media_url",
+    "thumbnail_url",
+];
+/** Fields read by `account()`. */
+export const ACCOUNT_FIELDS = [
+    "id",
+    "username",
+    "name",
+    "followers_count",
+    "follows_count",
+    "media_count",
+    "profile_picture_url",
+];
+/** Metrics requested by `storyInsights()`. */
+export const STORY_METRICS = ["views", "reach", "replies", "shares"];
+/** Metrics requested by `postInsights()`. Meta calls saves `saved`. */
+export const POST_METRICS = ["views", "reach", "likes", "comments", "saved", "shares"];
+/** Metrics requested by `reelInsights()`. Meta calls saves `saved`. */
+export const REEL_METRICS = ["views", "reach", "likes", "comments", "saved", "shares"];
+/** Default metrics for `accountInsights()`. */
+export const DEFAULT_ACCOUNT_METRICS = ["views", "reach", "likes", "comments", "shares", "replies"];
+const ID_PATTERN = /^[A-Za-z0-9_]+$/;
+function checkId(value, what) {
+    if (!value)
+        throw new TypeError(`${what} is required`);
+    if (!ID_PATTERN.test(value))
+        throw new TypeError(`${what} must contain only letters, digits or "_"`);
+    return value;
+}
+const str = (v) => (typeof v === "string" ? v : null);
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+function toMedia(raw) {
+    return {
+        id: String(raw.id ?? ""),
+        media_type: str(raw.media_type),
+        media_product_type: str(raw.media_product_type),
+        timestamp: str(raw.timestamp),
+        permalink: str(raw.permalink),
+        caption: str(raw.caption),
+        media_url: str(raw.media_url),
+        thumbnail_url: str(raw.thumbnail_url),
+    };
+}
+/** Read one number per metric name. A missing metric stays out of the map. */
+function metricValues(body) {
+    const out = new Map();
+    for (const row of body.data ?? []) {
+        if (!row.name)
+            continue;
+        const value = num(row.values?.[0]?.value) ?? num(row.total_value?.value);
+        if (value !== null)
+            out.set(row.name, value);
+    }
+    return out;
+}
+function combineSignals(a, b) {
+    if (!a)
+        return b;
+    const any = AbortSignal.any;
+    return any ? any([a, b]) : a;
+}
+export function createClient(options) {
+    if (!options || typeof options.accessToken !== "string" || options.accessToken.length === 0) {
+        throw new TypeError("accessToken is required");
+    }
+    const token = options.accessToken;
+    const apiVersion = options.apiVersion ?? DEFAULT_API_VERSION;
+    if (!/^v\d+\.\d+$/.test(apiVersion)) {
+        throw new TypeError(`apiVersion must look like "v25.0", got "${apiVersion}"`);
+    }
+    const baseUrl = `${GRAPH_HOST}/${apiVersion}`;
+    const doFetch = options.fetch ?? globalThis.fetch;
+    if (typeof doFetch !== "function") {
+        throw new TypeError("No fetch available. Use Node 20+ or pass options.fetch");
+    }
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    let lastUsage = null;
+    const userId = (o) => checkId(o?.igUserId ?? options.igUserId, "igUserId");
+    async function call(url, signal) {
+        url.searchParams.set("access_token", token);
+        const path = url.pathname;
+        let res;
+        try {
+            res = await doFetch(url.toString(), {
+                method: "GET",
+                headers: { accept: "application/json" },
+                signal: combineSignals(signal, AbortSignal.timeout(timeoutMs)),
+            });
+        }
+        catch (e) {
+            const isTimeout = e instanceof Error && e.name === "TimeoutError";
+            const reason = isTimeout
+                ? `timed out after ${timeoutMs} ms`
+                : e instanceof Error
+                    ? e.message
+                    : String(e);
+            throw new InstagramApiError({
+                message: redact(`Request to ${path} failed: ${reason}`, token),
+                status: 0,
+                type: isTimeout ? "Timeout" : "NetworkError",
+                path,
+            });
+        }
+        const usage = parseUsageHeaders(res.headers);
+        lastUsage = usage;
+        const text = await res.text();
+        let body = null;
+        try {
+            body = text ? JSON.parse(text) : null;
+        }
+        catch {
+            body = null;
+        }
+        const err = body?.error;
+        if (!res.ok || err) {
+            const detail = err?.message ?? `HTTP ${res.status}`;
+            const codes = [
+                err?.code !== undefined ? `code ${err.code}` : null,
+                err?.error_subcode !== undefined ? `subcode ${err.error_subcode}` : null,
+            ].filter(Boolean);
+            throw new InstagramApiError({
+                message: redact(`Instagram API error at ${path}: ${detail}${codes.length ? ` (${codes.join(", ")})` : ""}`, token),
+                status: res.status,
+                code: num(err?.code),
+                subcode: num(err?.error_subcode),
+                type: str(err?.type),
+                fbtraceId: str(err?.fbtrace_id),
+                path,
+                usage,
+            });
+        }
+        if (body === null || typeof body !== "object") {
+            throw new InstagramApiError({
+                message: `Instagram API returned a response that is not JSON at ${path}`,
+                status: res.status,
+                path,
+                usage,
+            });
+        }
+        return body;
+    }
+    function endpoint(path, params = {}) {
+        const url = new URL(`${baseUrl}${path}`);
+        for (const [k, v] of Object.entries(params))
+            if (v !== undefined)
+                url.searchParams.set(k, v);
+        return url;
+    }
+    /** Accept a `paging.next` URL only when it points at the same Graph host. */
+    function nextUrl(next) {
+        if (!next)
+            return null;
+        let url;
+        try {
+            url = new URL(next);
+        }
+        catch {
+            return null;
+        }
+        return url.origin === GRAPH_HOST ? url : null;
+    }
+    async function mediaInsights(mediaId, metrics, signal) {
+        const id = checkId(mediaId, "mediaId");
+        const body = await call(endpoint(`/${id}/insights`, { metric: metrics.join(",") }), signal);
+        const values = metricValues(body);
+        return (name) => values.get(name) ?? null;
+    }
+    function mediaParams(o) {
+        return {
+            fields: MEDIA_FIELDS.join(","),
+            limit: o.limit !== undefined ? String(o.limit) : undefined,
+            since: o.since !== undefined ? String(toUnixSeconds(o.since)) : undefined,
+            until: o.until !== undefined ? String(toUnixSeconds(o.until)) : undefined,
+            after: o.after,
+        };
+    }
+    function toPage(body) {
+        return {
+            data: (body.data ?? []).map(toMedia),
+            after: body.paging?.cursors?.after ?? null,
+            hasNext: Boolean(body.paging?.next),
+        };
+    }
+    const client = {
+        apiVersion,
+        baseUrl,
+        get lastUsage() {
+            return lastUsage;
+        },
+        async account(o) {
+            const raw = await call(endpoint(`/${userId(o)}`, { fields: ACCOUNT_FIELDS.join(",") }), o?.signal);
+            return {
+                id: String(raw.id ?? userId(o)),
+                username: str(raw.username),
+                name: str(raw.name),
+                followers_count: num(raw.followers_count),
+                follows_count: num(raw.follows_count),
+                media_count: num(raw.media_count),
+                profile_picture_url: str(raw.profile_picture_url),
+            };
+        },
+        async stories(o) {
+            const out = [];
+            let url = endpoint(`/${userId(o)}/stories`, { fields: MEDIA_FIELDS.join(",") });
+            while (url) {
+                const body = await call(url, o?.signal);
+                out.push(...(body.data ?? []).map(toMedia));
+                url = nextUrl(body.paging?.next);
+            }
+            return out;
+        },
+        async media(o = {}) {
+            return toPage(await call(endpoint(`/${userId(o)}/media`, mediaParams(o)), o.signal));
+        },
+        async *iterateMedia(o = {}) {
+            const max = o.max ?? Infinity;
+            let count = 0;
+            let url = endpoint(`/${userId(o)}/media`, mediaParams(o));
+            while (url && count < max) {
+                const body = await call(url, o.signal);
+                for (const raw of body.data ?? []) {
+                    yield toMedia(raw);
+                    if (++count >= max)
+                        return;
+                }
+                url = nextUrl(body.paging?.next);
+            }
+        },
+        async storyInsights(mediaId, o) {
+            const get = await mediaInsights(mediaId, STORY_METRICS, o?.signal);
+            return { views: get("views"), reach: get("reach"), replies: get("replies"), shares: get("shares") };
+        },
+        async postInsights(mediaId, o) {
+            const get = await mediaInsights(mediaId, POST_METRICS, o?.signal);
+            return {
+                views: get("views"),
+                reach: get("reach"),
+                likes: get("likes"),
+                comments: get("comments"),
+                saves: get("saved"),
+                shares: get("shares"),
+            };
+        },
+        async reelInsights(mediaId, o) {
+            const get = await mediaInsights(mediaId, REEL_METRICS, o?.signal);
+            return {
+                views: get("views"),
+                reach: get("reach"),
+                likes: get("likes"),
+                comments: get("comments"),
+                saves: get("saved"),
+                shares: get("shares"),
+            };
+        },
+        async accountInsights(o = {}) {
+            const metrics = o.metrics ?? DEFAULT_ACCOUNT_METRICS;
+            if (metrics.length === 0)
+                throw new TypeError("metrics must not be empty");
+            const metricType = o.metricType === undefined ? "total_value" : o.metricType;
+            const body = await call(endpoint(`/${userId(o)}/insights`, {
+                metric: metrics.join(","),
+                period: o.period ?? "day",
+                metric_type: metricType ?? undefined,
+                since: o.since !== undefined ? String(toUnixSeconds(o.since)) : undefined,
+                until: o.until !== undefined ? String(toUnixSeconds(o.until)) : undefined,
+                breakdown: o.breakdown,
+                timeframe: o.timeframe,
+            }), o.signal);
+            return (body.data ?? []).map((row) => ({
+                name: row.name ?? "",
+                period: str(row.period),
+                title: str(row.title),
+                description: str(row.description),
+                total: num(row.total_value?.value),
+                values: (row.values ?? []).map((v) => ({ value: v.value ?? null, endTime: str(v.end_time) })),
+                breakdowns: (row.total_value?.breakdowns ?? []).map((b) => ({
+                    dimensionKeys: b.dimension_keys ?? [],
+                    results: (b.results ?? [])
+                        .filter((r) => Array.isArray(r.dimension_values) && num(r.value) !== null)
+                        .map((r) => ({ dimensionValues: r.dimension_values, value: r.value })),
+                })),
+            }));
+        },
+    };
+    return client;
+}

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+import type { RateLimitUsage } from "./usage.js";
+/**
+ * Meta error codes for rate limits: 4 (app), 17 (user), 32 (page),
+ * 613 (call rate), 80001 (Pages use case), 80002 (Instagram use case).
+ */
+export declare const RATE_LIMIT_CODES: ReadonlySet<number>;
+/** Code 190: the access token is expired, revoked or not valid. */
+export declare const AUTH_ERROR_CODES: ReadonlySet<number>;
+/**
+ * Subcodes that mean the user must log in again: 458 (app removed),
+ * 460 (password changed), 463 (token expired), 467 (token not valid).
+ */
+export declare const AUTH_ERROR_SUBCODES: ReadonlySet<number>;
+export type InstagramApiErrorInit = {
+    message: string;
+    status: number;
+    code?: number | null;
+    subcode?: number | null;
+    type?: string | null;
+    fbtraceId?: string | null;
+    path?: string | null;
+    usage?: RateLimitUsage | null;
+};
+/**
+ * A failed Graph API call. `message` never contains the access token.
+ * `status` is 0 when the request did not reach Meta (network error or timeout).
+ */
+export declare class InstagramApiError extends Error {
+    /** The HTTP status. 0 for a network error or a timeout. */
+    readonly status: number;
+    /** Meta's `error.code`. */
+    readonly code: number | null;
+    /** Meta's `error.error_subcode`. */
+    readonly subcode: number | null;
+    /** Meta's `error.type`, for example `OAuthException`. */
+    readonly type: string | null;
+    /** Meta's `error.fbtrace_id`. Give it to Meta support when you report a problem. */
+    readonly fbtraceId: string | null;
+    /** The API path that failed, without the query string. */
+    readonly path: string | null;
+    /** The rate-limit usage headers of the failed response, if Meta sent them. */
+    readonly usage: RateLimitUsage | null;
+    constructor(init: InstagramApiErrorInit);
+    /** True when Meta throttled the call. Wait before you try again. */
+    get isRateLimit(): boolean;
+    /** True when the token is expired or not valid (code 190 or an auth subcode). Get a new token. */
+    get isAuthError(): boolean;
+}
+/** Replace every copy of `secret` in `text` with `[redacted]`. */
+export declare function redact(text: string, secret: string | undefined): string;

package/dist/errors.js

@@ -0,0 +1,63 @@
+/**
+ * Meta error codes for rate limits: 4 (app), 17 (user), 32 (page),
+ * 613 (call rate), 80001 (Pages use case), 80002 (Instagram use case).
+ */
+export const RATE_LIMIT_CODES = new Set([4, 17, 32, 613, 80001, 80002]);
+/** Code 190: the access token is expired, revoked or not valid. */
+export const AUTH_ERROR_CODES = new Set([190]);
+/**
+ * Subcodes that mean the user must log in again: 458 (app removed),
+ * 460 (password changed), 463 (token expired), 467 (token not valid).
+ */
+export const AUTH_ERROR_SUBCODES = new Set([458, 460, 463, 467]);
+/**
+ * A failed Graph API call. `message` never contains the access token.
+ * `status` is 0 when the request did not reach Meta (network error or timeout).
+ */
+export class InstagramApiError extends Error {
+    /** The HTTP status. 0 for a network error or a timeout. */
+    status;
+    /** Meta's `error.code`. */
+    code;
+    /** Meta's `error.error_subcode`. */
+    subcode;
+    /** Meta's `error.type`, for example `OAuthException`. */
+    type;
+    /** Meta's `error.fbtrace_id`. Give it to Meta support when you report a problem. */
+    fbtraceId;
+    /** The API path that failed, without the query string. */
+    path;
+    /** The rate-limit usage headers of the failed response, if Meta sent them. */
+    usage;
+    constructor(init) {
+        super(init.message);
+        this.name = "InstagramApiError";
+        this.status = init.status;
+        this.code = init.code ?? null;
+        this.subcode = init.subcode ?? null;
+        this.type = init.type ?? null;
+        this.fbtraceId = init.fbtraceId ?? null;
+        this.path = init.path ?? null;
+        this.usage = init.usage ?? null;
+    }
+    /** True when Meta throttled the call. Wait before you try again. */
+    get isRateLimit() {
+        return this.code !== null && RATE_LIMIT_CODES.has(this.code);
+    }
+    /** True when the token is expired or not valid (code 190 or an auth subcode). Get a new token. */
+    get isAuthError() {
+        if (this.code !== null && AUTH_ERROR_CODES.has(this.code))
+            return true;
+        return this.subcode !== null && AUTH_ERROR_SUBCODES.has(this.subcode);
+    }
+}
+/** Replace every copy of `secret` in `text` with `[redacted]`. */
+export function redact(text, secret) {
+    if (!secret || secret.length < 4)
+        return text;
+    let out = text.split(secret).join("[redacted]");
+    const encoded = encodeURIComponent(secret);
+    if (encoded !== secret)
+        out = out.split(encoded).join("[redacted]");
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createClient, DEFAULT_API_VERSION, GRAPH_HOST, MEDIA_FIELDS, ACCOUNT_FIELDS, STORY_METRICS, POST_METRICS, REEL_METRICS, DEFAULT_ACCOUNT_METRICS, } from "./client.js";
+export type { ClientOptions, CallOptions, InstagramClient, Account, Media, MediaType, MediaProductType, MediaOptions, MediaPage, StoryInsights, PostInsights, ReelInsights, AccountInsightsOptions, AccountInsight, AccountInsightBreakdown, } from "./client.js";
+export { InstagramApiError, RATE_LIMIT_CODES, AUTH_ERROR_CODES, AUTH_ERROR_SUBCODES, } from "./errors.js";
+export type { InstagramApiErrorInit } from "./errors.js";
+export { parseUsageHeaders } from "./usage.js";
+export type { RateLimitUsage, AppUsage, BusinessUseCaseUsage } from "./usage.js";
+export type { TimeInput } from "./time.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createClient, DEFAULT_API_VERSION, GRAPH_HOST, MEDIA_FIELDS, ACCOUNT_FIELDS, STORY_METRICS, POST_METRICS, REEL_METRICS, DEFAULT_ACCOUNT_METRICS, } from "./client.js";
+export { InstagramApiError, RATE_LIMIT_CODES, AUTH_ERROR_CODES, AUTH_ERROR_SUBCODES, } from "./errors.js";
+export { parseUsageHeaders } from "./usage.js";

package/dist/time.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A point in time: a `Date`, epoch milliseconds, or a date string such as
+ * `2026-10-01` or `2026-10-01T12:00:00Z`.
+ */
+export type TimeInput = Date | number | string;
+/** Convert a `TimeInput` to Unix seconds, the unit Graph API `since`/`until` use. */
+export declare function toUnixSeconds(input: TimeInput): number;

package/dist/time.js

@@ -0,0 +1,8 @@
+/** Convert a `TimeInput` to Unix seconds, the unit Graph API `since`/`until` use. */
+export function toUnixSeconds(input) {
+    const ms = input instanceof Date ? input.getTime() : typeof input === "number" ? input : Date.parse(input);
+    if (!Number.isFinite(ms)) {
+        throw new TypeError(`Not a valid date: ${String(input)}`);
+    }
+    return Math.floor(ms / 1000);
+}

package/dist/usage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Meta's rate-limit usage headers. Each value is a percentage of the limit
+ * (0-100). Meta throttles when any one of them reaches 100.
+ */
+export type AppUsage = {
+    call_count: number;
+    total_time: number;
+    total_cputime: number;
+};
+export type BusinessUseCaseUsage = AppUsage & {
+    /** The use case, for example `instagram` or `pages`. */
+    type: string;
+    /** Minutes until the app can call again. 0 when not throttled. */
+    estimated_time_to_regain_access: number;
+};
+export type RateLimitUsage = {
+    /** From `x-app-usage`. Null when the header is missing. */
+    app: AppUsage | null;
+    /** From `x-business-use-case-usage`, keyed by business object id. */
+    businessUseCase: Record<string, BusinessUseCaseUsage[]>;
+};
+/** Parse `x-app-usage` and `x-business-use-case-usage`. Bad JSON gives empty values. */
+export declare function parseUsageHeaders(headers: Headers): RateLimitUsage;

package/dist/usage.js

@@ -0,0 +1,55 @@
+function parseJson(raw) {
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function pct(n) {
+    return typeof n === "number" && Number.isFinite(n) ? Math.max(0, n) : 0;
+}
+function toAppUsage(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const o = raw;
+    return {
+        call_count: pct(o.call_count),
+        total_time: pct(o.total_time),
+        total_cputime: pct(o.total_cputime),
+    };
+}
+function toBuc(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const out = {};
+    for (const [id, entries] of Object.entries(raw)) {
+        if (!Array.isArray(entries))
+            continue;
+        const parsed = [];
+        for (const e of entries) {
+            if (!e || typeof e !== "object")
+                continue;
+            const o = e;
+            parsed.push({
+                type: typeof o.type === "string" ? o.type : "unknown",
+                call_count: pct(o.call_count),
+                total_time: pct(o.total_time),
+                total_cputime: pct(o.total_cputime),
+                estimated_time_to_regain_access: pct(o.estimated_time_to_regain_access),
+            });
+        }
+        if (parsed.length > 0)
+            out[id] = parsed;
+    }
+    return out;
+}
+/** Parse `x-app-usage` and `x-business-use-case-usage`. Bad JSON gives empty values. */
+export function parseUsageHeaders(headers) {
+    return {
+        app: toAppUsage(parseJson(headers.get("x-app-usage"))),
+        businessUseCase: toBuc(parseJson(headers.get("x-business-use-case-usage"))),
+    };
+}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@storylinkpro/instagram-stories-api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Instagram Graph API client and CLI for Node.js and TypeScript: read Instagram Stories, posts, reels and their insights (views, reach, replies, likes, saves, shares). Typed, zero dependencies.",
+  "keywords": [
+    "instagram",
+    "instagram-api",
+    "instagram-graph-api",
+    "instagram-stories",
+    "instagram-story",
+    "instagram-insights",
+    "instagram-analytics",
+    "instagram-reels",
+    "instagram-business",
+    "meta-graph-api",
+    "facebook-graph-api",
+    "graph-api",
+    "social-media",
+    "analytics",
+    "insights",
+    "api-client",
+    "cli",
+    "typescript",
+    "nodejs",
+    "zero-dependency"
+  ],
+  "homepage": "https://github.com/storylinkpro/instagram-stories-api#readme",
+  "bugs": {
+    "url": "https://github.com/storylinkpro/instagram-stories-api/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/storylinkpro/instagram-stories-api.git"
+  },
+  "license": "MIT",
+  "author": "Storylink (https://storylink.pro)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "instagram-stories-api": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "check": "npm run typecheck && npm test && npm run build",
+    "prepublishOnly": "npm run check"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.1",
+    "typescript": "5.9.3",
+    "vitest": "5.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}