# Advanced Instagram Story Scraper – Metadata, OCR & Transcripts (`lance_api/advanced-instagram-story-scraper`) Actor

Scrape public Instagram Stories with rich metadata: mentions, links, music, reshares, media variants and labels. Add image OCR, original-language transcripts and media saving. No Instagram login required.

- **URL**: https://apify.com/lance_api/advanced-instagram-story-scraper.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Instagram Story Scraper API – Advanced Metadata, OCR & Transcripts

**Scrape public Instagram Stories with rich structured metadata, including mentions, link stickers, music, reshared Posts/Reels, optional image OCR, video transcription, and media saving.**

Enter an Instagram username, @username, or profile URL to receive currently accessible public Stories as structured JSON. No Instagram login credentials are required.

- **Rich Story metadata:** work with available mentions, links, music, reshares, image/video variants, partnership metadata, and available platform-provided AI-label metadata in your own tools.
- **Optional image OCR:** extract visible text from image Stories and return the OCR text together with useful literal patterns such as mentions, links, prices, and promo codes.
- **Optional video transcripts:** turn spoken Story audio into original-language text for search and other downstream workflows.
- **Optional media saving:** save actual Story images and videos to your Apify storage for an authorized archive; standard Apify storage charges may apply while files are retained.
- **Batch up to 100 unique valid profiles:** usernames are normalized and deduplicated before processing, helping avoid duplicate work and charges within a run.

**Predictable base pricing:** budget by the number of unique profiles you submit for processing. The base model charges once per profile, whether it returns many Stories, no Stories, or an unsuccessful outcome. There is no additional charge per Story.

Optional OCR and media saving are charged for successfully delivered results. Video transcription is charged when paid speech recognition is performed, including when no spoken text is detected. Keep them off when you only need Story metadata.

### Quick start

1. [Open the Actor](https://console.apify.com/actors/xyXKCfLLjAyDaQWAU) and enter a public username, @username, or Instagram profile URL.
2. For your first run, leave the three optional features off and click **Start**.
3. Open the run's **Dataset** to inspect or export the Story rows. Check the run summary for each profile's outcome.

```json
{
  "usernames": ["natgeo"]
}
```

The usernames list is required. Story availability changes, so a public profile can return a confirmed no-active-Stories status instead of Story rows.

#### Short output example

**Illustrative output — values are examples, not a captured live result.** Selected fields from an image Story with OCR and media saving enabled are shown below; actual Story rows include additional metadata fields.

```json
{
  "record_type": "story",
  "status": "success",
  "pk": "4000000000000000001",
  "media_format": "image",
  "taken_at_iso": "2026-10-20T12:00:00.000Z",
  "user": { "username": "example_creator" },
  "media_url": "https://media.example.com/story.jpg",
  "reel_mentions": [],
  "story_link_stickers": [],
  "music_metadata": null,
  "image_text": {
    "text": "USD 20.00\nPromo code: SAVE10",
    "mentions": [], "hashtags": [], "urls": [], "emails": [],
    "phone_numbers": [], "prices": ["USD 20.00"], "discounts": [],
    "promo_codes": ["SAVE10"], "dates": [], "times": []
  },
  "transcript": null,
  "saved_media": {
    "url": "https://api.apify.com/v2/key-value-stores/EXAMPLE_STORE/records/story-4000000000000000001.jpg",
    "key": "story-4000000000000000001.jpg",
    "content_type": "image/jpeg",
    "bytes": 12345
  }
}
```

`image_text` applies to images and `transcript` applies to videos. Optional fields can be null when disabled, inapplicable, unsuccessful, or skipped for budget. A completed recognition with no spoken text also returns `transcript: null`; check `transcript_status` to distinguish these outcomes.

### Input

| Field | Type | Required | Default | Prefill | What it does |
|---|---|---|---|---|---|
| `usernames` | string array | Yes | `["instagram"]` | `["instagram"]` | Usernames, @usernames, or Instagram profile URLs; up to 100 unique valid profiles after canonical duplicate removal |
| `extractTextFromImages` | boolean | No | `false` | None | Extract visible text from image Stories and return the OCR text and literal patterns |
| `transcribeStoryVideos` | boolean | No | `false` | None | Transcribe spoken audio from Story videos in its original language |
| `saveMedia` | boolean | No | `false` | None | Save a copy of actual Story images or videos to the run's Apify Key-Value Store; retained files may incur standard Apify storage charges |

Default and prefill values describe the Console input form; API calls must supply `usernames`. The three optional switches default to false when omitted. These are the only supported input fields.

Repeated references such as `natgeo`, `@NatGeo`, and `https://www.instagram.com/natgeo/` count as one profile. The limit of **100 unique valid profiles per run** applies after validation and duplicate removal. A larger canonical batch is rejected before processing; it is not silently shortened. Submit Instagram profile URLs, rather than individual Post, Reel, or Story URLs.

Optional features have separate charges. Enable only the features you need. Image OCR applies to image Stories; it does not scan video thumbnails or video frames.

### Advanced Instagram Story metadata

A delivered Story produces one row with `record_type: "story"` and `status: "success"`. The Actor's supported metadata fields are included whether or not you enable optional features. Field availability varies by Story; Advanced Metadata does not mean every possible Instagram feature is supported.

| Fields | Type and units | Meaning |
|---|---|---|
| `pk`, `id`, `code` | string or null | Story identity and available shortcode; string IDs preserve large values for joins and duplicate checks |
| `user` | object or null | Available owner identity, profile picture, privacy and verification information; individual values can be null |
| `media_format`, `media_type`, `product_type` | string; number or null; string or null | Image/video format and available media type information |
| `taken_at`, `expiring_at`, corresponding `_iso` fields | number or null, Unix seconds; string or null, UTC ISO 8601 | Available publication and expiry times |
| `media_url`, `image_url`, `video_url` | string or null | Convenient URLs selected from available Story variants |
| `image_versions2`, `video_versions` | object or null; array | Available image candidates and video renditions, including dimensions and rendition details |
| `original_width`, `original_height`, `video_duration`, `has_audio` | number or null, pixels/seconds; boolean or null | Available dimensions, video duration, and audio availability |
| `caption_text`, `accessibility_caption` | string or null | Available caption and accessibility text |
| `reel_mentions`, `story_link_stickers` | array or null | Mention identities and link metadata, with available placement/timing |
| `story_music_stickers`, `music_metadata` | array or null; object or null | Available music assets and summary, with distinct asset and cluster IDs |
| `story_feed_media` | array or null | Available reshared Post/Reel identifiers and links |
| `is_paid_partnership`, `creative_config`, `ai_label_info` | boolean or null; object or null; object or null | Explicit partnership information, selected creative details and available platform-provided AI-label information |
| `image_text`, `transcript`, `saved_media` | object or null | Requested optional results, described below |
| `transcript_status` | string, when present | Distinguishes completed speech recognition, no speech, technical failure, budget skipping, and unrequested work |

Unknown metadata remains null; collection fields can be null or empty arrays. Missing values are not filled with guesses. Public content URLs retain their query parameters and fragments. Sticker times and music durations use milliseconds; video duration uses seconds.

#### Extract text from Story images

`image_text.text` contains the full OCR text returned for that image, without trimming or rewriting it. Line breaks and whitespace are preserved. Other fields help you work with explicit patterns in that text:

`mentions`, `hashtags`, `urls`, `emails`, `phone_numbers`, `prices`, `discounts`, `promo_codes`, `dates`, and `times` are string arrays.

Arrays remove duplicates while keeping the order of first appearance. Extraction is conservative: unlabeled numbers are not guessed as telephone numbers, ambiguous dates are not converted, and a visible company name is not classified as a brand. The OCR text remains available even when every structured array is empty.

A successful extraction can return `text: ""` and empty arrays when no text is recognized. This is a successful, chargeable image text result. Technical failures leave `image_text: null`, keep the core Story, and do not incur an image text charge. OCR can contain recognition errors or miss visible text.

#### Transcribe Story videos

A completed `transcript` contains `text` and `language`. Text stays in its original language. Language is null when it cannot be reliably supplied; no translation or summary is added.

Video transcription is charged once per Story video when paid speech recognition is actually performed, including music-only, silent, and other no-speech results. It is **not charged per minute**. Requests that fail before recognition begins are not charged; a later technical failure is charged only when inference cost can be confirmed.

`transcript_status` distinguishes `transcript_success`, `no_speech`, `technical_failure`, `budget_skipped`, `not_attempted`, `not_applicable`, and `not_requested`. A normal no-speech result keeps the successful Story row with `transcript: null` and `transcript_status: "no_speech"`. Recognition charges also apply if a later result-storage step fails, since recognition has already been performed.

#### Save Story media to Apify storage

`saved_media` contains `url` and `key` as strings, `content_type` as a MIME-type string, and `bytes` as the saved file size in bytes. An image Story saves its image; a video Story saves its video, not just its thumbnail. Keys use the Story ID and media extension.

The **$0.005 Media saved** event is the Actor fee for successfully copying one Story image or video to the run's Apify Key-Value Store and delivering its saved link. It does **not** include unlimited free storage. Retained files use your Apify Storage and may incur standard Apify storage charges. Unsuccessful saves leave `saved_media: null` and do not incur the media-saving event fee.

The run's default Key-Value Store is **unnamed** and follows your Apify account's data-retention settings. If you rename the store, it becomes **named storage**, which Apify retains indefinitely until you delete it; storage usage may still be charged while the data is retained. See the [Apify Storage documentation](https://docs.apify.com/storage) for the current retention rules and pricing.

#### Profile outcomes and billing

Under the profile-based model, a unique, valid profile accepted for processing incurs one base fee once processing begins. The fee pays for the processing attempt and applies regardless of its outcome.

| Outcome | Dataset | Profile processing fee | Additional Story fee |
|---|---|---|---|
| Stories delivered | Story rows | Yes, once per profile | None |
| Confirmed `no_stories` | Profile status row | Yes, once per profile | None |
| Not found | No row | Yes, if accepted and processing begins | None |
| Private / restricted | No row | Yes, if accepted and processing begins | None |
| Technical failure | No row, or already delivered partial rows | Yes, if processing begins | None |
| Invalid input rejected before processing | No row | No | None |
| Duplicate reference to the same profile in one run | No additional rows | No additional profile fee | None |

An empty or unsuccessful outcome does not refund the profile processing fee. Profiles that are rejected or never started are not processing attempts. Accepted profiles are counted after canonical duplicate removal.

A confirmed public profile without active Stories produces a `profile_status` record rather than a Story. For example, the following is an illustrative status record, not a captured live result:

```json
{
  "record_type": "profile_status",
  "status": "no_stories",
  "reason": "no_active_stories",
  "username": "example_creator",
  "user_id": "123456789",
  "profile_url": "https://www.instagram.com/example_creator/",
  "story_count": 0
}
```

The profile fee is the same whether the attempt returns zero, one, or many Stories. Partial delivery or technical failure does not remove that base fee. OCR and media saving add a fee for successful delivery; video transcription adds a fee for confirmed paid recognition, including no speech. A failed optional feature does not discard its core Story. Check the run summary for each profile's outcome.

#### Dataset views and run summary

**Overview** shows the record type, profile, main Story fields and optional results. **Full Metadata** preserves all of this Actor's public output fields as nested JSON; the name does not promise every possible Instagram metadata field. **Marketing Signals** focuses on mentions, links, music, reshared media and requested text/media results.

The run's `OUTPUT` record contains total counts and a final `profiles[]` summary. Each entry includes the submitted input, canonical username, user ID when known, final status/reason, delivered Story count, and confirmation of the profile processing charge. The summary can be `SUCCEEDED`, `PARTIAL`, or `FAILED`; check it even when the run has finished. One unavailable profile does not prevent other accepted profiles from completing.

### Profile-based pricing and budget control

**No per-Story fee. Pay once per unique Profile when processing starts.** Core Story metadata is included, with rates as low as **$4 per 1,000 profiles on Business**.

| Apify plan | Profile processing | Per 1,000 |
|---|---:|---:|
| Free / No discount | $0.007 | $7.00 |
| Starter / Bronze discount | $0.005 | $5.00 |
| Scale / Silver discount | $0.0045 | $4.50 |
| Business / Gold discount | $0.004 | $4.00 |

**On Starter, 100 unique profiles cost $0.50 in base Profile fees.** Whether a profile returns zero, one, or many Stories, there is no additional per-Story Actor fee.

Each unique valid profile is charged once when processing starts, including attempts that find no Stories, cannot access or find the profile, or fail technically. Duplicate references within a run, invalid inputs, rejected batches, and profiles that cannot start because of the spending limit do not incur a processing fee. No processing starts if its charge cannot be confirmed.

#### Optional feature charges

Enable only the extra results you need. These add-ons are charged separately from the Profile fee. OCR and saving are billed on successful delivery; transcription is billed on confirmed paid recognition.

| Optional add-on | Free | Starter | Scale | Business | Billing unit |
|---|---:|---:|---:|---:|---|
| Image text | $0.005 | $0.005 | $0.005 | $0.005 | Per Story image with a successfully delivered OCR result |
| Video transcript | $0.015 | $0.012 | $0.011 | $0.010 | Per Story video with paid speech recognition performed, including no speech |
| Media saved | $0.005 | $0.005 | $0.005 | $0.005 | Per Story image/video successfully saved and delivered |

Video transcription is charged **per video, not per minute**. Successful OCR with empty text is still chargeable. Media saving is charged only after the actual copy is saved and its download link is delivered.

| Optional feature | Billing unit | Charged when | No optional fee when |
|---|---|---|---|
| Image text | Per Story image | Requested OCR succeeds and the result is delivered, including an empty text result | Disabled, skipped, or technically unsuccessful |
| Video transcript | Per Story video, not per minute | Paid speech recognition is confirmed, including no speech | Disabled, budget skipped, or failure without confirmed inference cost |
| Media saving | Per Story image or video | The file is saved and its link is delivered with the Story | Disabled, skipped, or saving fails |

A failed optional feature does not cancel the base profile fee. Optional charges depend on the work performed and the billing conditions above, so enable them only when needed. With all three options off, Story count does not add to the base processing charge. The Actor's **Pricing** tab currently shows **Platform usage as Free** for the Actor run, but this does not provide unlimited free post-run storage. The **Media saved** event covers the save operation; files retained afterward continue to use your Apify Storage and may incur standard storage charges according to your account and retention settings. See the [Apify Storage documentation](https://docs.apify.com/storage) for current storage retention and pricing, and the Pricing tab for current Actor rates.

Use the run spending limit to control your budget and review the profile summary for the work actually started and delivered. A profile that is not started because the budget is insufficient does not incur a processing fee. An optional result can be null when its budget cannot be reserved.

### Use cases for structured Story data

- **Brand and creator monitoring:** use the returned data for tracking public Story activity and changes across scheduled runs in your own monitoring workflow.
- **Campaign monitoring:** use the returned data for reviewing available mentions, link stickers, and partnership metadata alongside your campaign records.
- **Promotion tracking:** use the returned data for collecting literal OCR prices, discounts, and promo codes into your own comparison tools.
- **Creator and competitor research:** use the returned data for comparing available music, reshared Posts/Reels, and Story activity across profiles.
- **Spoken-content workflows:** use the returned data for searching or organizing original-language transcripts in your own tools.
- **Authorized media archiving:** use the returned data for archiving permitted Story media with `saveMedia` and Apify storage, subject to your retention settings and standard Apify storage charges.
- **Automation and AI pipelines:** use the returned data for n8n, Make, databases, and AI workflows that consume structured Story JSON; any downstream analysis is performed in your own tools.

### API usage

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lance_api/advanced-instagram-story-scraper').call({
  usernames: ['natgeo'],
  saveMedia: true,
});
// Read the first Dataset page; paginate for larger runs.
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const summary = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('OUTPUT');
console.log(items, summary?.value);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('lance_api/advanced-instagram-story-scraper').call(
    run_input={'usernames': ['natgeo'], 'saveMedia': True}
)
items = list(client.dataset(run['defaultDatasetId']).iterate_items())
summary = client.key_value_store(run['defaultKeyValueStoreId']).get_record('OUTPUT')
print(items, summary['value'] if summary else None)
```

Use your own token and an account with access to the Actor. SDK calls wait for the run to finish before reading its results.

### Limits and responsible use

Only currently accessible public Stories are supported. Availability and music permissions can change, media links can expire, and a fixed number of Stories or a historical archive is not guaranteed. Missing metadata is not proof that an Instagram feature was absent. Audio transcription depends on available speech. Image OCR can contain recognition errors; literal structured extraction deliberately leaves uncertain values empty.

Polls, questions, quizzes, countdowns, sliders, location/hashtag stickers, Story comments, video-frame OCR, semantic classifications and additional profile enrichment are outside this version.

Use data only where permitted and respect privacy, copyright, applicable law, and platform terms.

### FAQ

#### Do I need Instagram login credentials?

No. Submit public usernames or profile URLs; no Instagram login, password, cookies, or session is required.

#### Can it scrape private Stories?

No. Private or otherwise restricted Stories are not delivered. Under the profile-based model, an accepted profile still incurs its processing fee if the attempt begins, even when access is restricted. The outcome appears in the run summary.

#### What happens when a public profile has no active Stories?

A confirmed empty public profile produces a `profile_status` row with `status: "no_stories"`. The profile processing fee applies, with no additional Story fee. Technical failures also retain the profile processing fee but are not reported as confirmed empty results.

#### Does OCR work on video frames?

No. Image OCR processes image Stories only, not video frames or video thumbnails.

#### Does video transcription translate or summarize?

No. It returns recognized speech in its original language, with language information when reliably available. Translation and summarization are downstream tasks for your own tools.

#### Are Story media URLs permanent?

No. Original media links can expire or stop working. Use optional media saving for an authorized copy in Apify storage.

#### How long does saved media remain available?

Saved media is written to the run's default **unnamed** Apify Key-Value Store, so availability follows your account's data-retention policy. You can rename the store to make it **named storage**, which Apify retains indefinitely until you delete it. Retained storage is not necessarily free: standard Apify storage charges may apply based on usage and duration. See the [Apify Storage documentation](https://docs.apify.com/storage) for current retention rules and pricing.

#### Are failed OCR, transcript, or media-save attempts charged?

OCR and media-save technical failures do not incur their optional fee. Video recognition is chargeable once performed, including no speech; technical failures are charged only with confirmed inference cost. Successful OCR with empty text is chargeable. These optional outcomes do not remove the base profile processing fee, and there is no separate per-Story fee under that model.

#### Why can Story counts differ between runs?

Stories are published, expire, are deleted, or become inaccessible between runs. Data availability can also affect delivery; review each profile's summary rather than assuming a fixed Story count. The base fee remains one charge per attempted profile, regardless of Story count.

#### What is included in Advanced Metadata?

Available Story identity and timestamps, image/video variants, owner identity, captions, mentions, links, music, reshared Posts/Reels, partnership information, selected creative details, and available platform-provided AI-label metadata. Fields can be null or empty, and unsupported interactive stickers and Story comments are not included. The Full Metadata view displays all public fields this Actor supports.

### Support

Contact **lanceapi2026@hotmail.com** or open an issue on the Actor page. Include the **Run ID**, non-sensitive input, visible status/reason, and expected versus actual result.

**Do not send Apify Tokens, Instagram cookies or sessions, passwords, API keys, proxy credentials, or Authorization headers.**

# Actor input Schema

## `usernames` (type: `array`):

Username, @username, or Instagram profile URL. Up to 100 unique valid public profiles per run after automatic duplicate removal. Retrieves active public Stories without an Instagram login.

## `extractTextFromImages` (type: `boolean`):

Extract visible text from image Stories and return the original text together with useful structured details.

## `transcribeStoryVideos` (type: `boolean`):

Enable to run speech recognition on Story videos. Charged once per video when recognition is performed, including no speech; not per minute. Failures without confirmed recognition cost are not charged.

## `saveMedia` (type: `boolean`):

Download Story images/videos to this run's Apify Key-Value Store. The Media saved fee covers the save operation only. Retained files use your Apify Storage and may incur standard storage charges. The default store is unnamed and follows your account retention settings; named storage is retained indefinitely until deleted. See https://docs.apify.com/storage for current retention and pricing.

## Actor input object example

```json
{
  "usernames": [
    "instagram"
  ],
  "extractTextFromImages": false,
  "transcribeStoryVideos": false,
  "saveMedia": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Story rows and confirmed no-active-Stories profile status records, with requested text, transcript, and saved media results.

## `runSummary` (type: `string`):

Final profile statuses, delivered Story counts, and charging confirmation.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "usernames": [
        "instagram"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/advanced-instagram-story-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "usernames": ["instagram"] }

# Run the Actor and wait for it to finish
run = client.actor("lance_api/advanced-instagram-story-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "usernames": [
    "instagram"
  ]
}' |
apify call lance_api/advanced-instagram-story-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lance_api/advanced-instagram-story-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xyXKCfLLjAyDaQWAU/builds/BOXYkKUqbdTppeNmt/openapi.json