Add YouTube transcripts to your Custom GPT.

What you need.

Three checkpoints:

1. 1A ChatGPT Plus or Team subscription. Custom GPTs require Plus or higher. Free ChatGPT can use existing Custom GPTs but not build them.
2. 2A Scority API key. Request one through the contact page. Scority can confirm current quota and access details for your workflow.
3. 3Basic familiarity with the Custom GPT builder. If you’ve never built one, OpenAI’s Custom GPT documentation is a good start.

Open the Custom GPT builder.

Either create a new GPT or edit an existing one.

1. 1Go to chatgpt.com/gpts (or click your name → My GPTs)
2. 2Click Create to make a new GPT, or Edit an existing one
3. 3Click the Configure tab (not “Create” tab, which uses conversational setup)
4. 4Scroll to the bottom and click Create new action

You’re now in the Action editor.

Set authentication.

Scority uses an x-api-key header. Set this up before you paste the schema so requests authenticate correctly.

1. 1Click Authentication at the top of the action editor
2. 2Select API Key as the type
3. 3Set:
   • API Key: Your Scority key (YOUR_API_KEY)
   • Auth Type: Custom
   • Custom Header Name: x-api-key
4. 4Click Save

The key belongs in the action authentication settings, not in GPT instructions, prompts, screenshots or public config files.

Paste the OpenAPI schema.

Custom GPT Actions are defined by an OpenAPI 3.1 schema. Scority publishes one at api.scority.ai/openapi.json — but for Custom GPTs, paste this trimmed version directly into the schema editor.

The public Scority API is intentionally narrow. This schema exposes the current transcript action and leaves out private dashboard, billing and operator routes.

openapi: 3.1.0
info:
  title: Scority API (for Custom GPTs)
  version: 1.0.0
  description: |
    YouTube transcript access for Custom GPT integrations.
servers:
  - url: https://api.scority.ai
paths:
  /v1/youtube/transcript:
    get:
      operationId: getTranscript
      summary: Fetch the transcript for a YouTube video
      description: |
        Returns transcript text and timestamped segments when captions are accessible.
      parameters:
        - name: video_id
          in: query
          schema: { type: string }
          description: YouTube video ID. Send either video_id or video_url.
        - name: video_url
          in: query
          schema: { type: string }
          description: Full YouTube URL. Send either video_url or video_id.
        - name: language
          in: query
          schema: { type: string }
          description: Optional requested caption language, such as en or en-US.
      responses:
        "200":
          description: Transcript fetched successfully
          content:
            application/json:
              schema:
                type: object
                properties:
                  text: { type: string }
                  language: { type: string }
                  source: { type: string }
                  segments:
                    type: array
                    items:
                      type: object
                      properties:
                        text: { type: string }
                        start: { type: number }
                        duration: { type: number }
        "400":
          description: Invalid or ambiguous request
        "401":
          description: Missing or invalid API key
        "404":
          description: Transcript not available
        "429":
          description: Rate limit or monthly quota reached
        "502":
          description: Upstream transcript fetch failed

components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

security:
  - ApiKeyAuth: []

openapi: 3.1.0
info:
  title: Scority API (for Custom GPTs)
  version: 1.0.0
  description: |
    YouTube transcript access for Custom GPT integrations.
servers:
  - url: https://api.scority.ai
paths:
  /v1/youtube/transcript:
    get:
      operationId: getTranscript
      summary: Fetch the transcript for a YouTube video
      description: |
        Returns transcript text and timestamped segments when captions are accessible.
      parameters:
        - name: video_id
          in: query
          schema: { type: string }
          description: YouTube video ID. Send either video_id or video_url.
        - name: video_url
          in: query
          schema: { type: string }
          description: Full YouTube URL. Send either video_url or video_id.
        - name: language
          in: query
          schema: { type: string }
          description: Optional requested caption language, such as en or en-US.
      responses:
        "200":
          description: Transcript fetched successfully
          content:
            application/json:
              schema:
                type: object
                properties:
                  text: { type: string }
                  language: { type: string }
                  source: { type: string }
                  segments:
                    type: array
                    items:
                      type: object
                      properties:
                        text: { type: string }
                        start: { type: number }
                        duration: { type: number }
        "400":
          description: Invalid or ambiguous request
        "401":
          description: Missing or invalid API key
        "404":
          description: Transcript not available
        "429":
          description: Rate limit or monthly quota reached
        "502":
          description: Upstream transcript fetch failed

components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

security:
  - ApiKeyAuth: []

Click Save. The Custom GPT builder validates the schema and lists the available action.

Add to GPT instructions.

The schema makes the action available; the GPT’s instructions teach it when to use the action.

Add to your GPT’s Instructions:

You have access to the Scority Transcript API. Use it when:

- The user provides a YouTube URL — call getTranscript with the URL.
- The user provides a YouTube video ID — call getTranscript with video_id.
- If the user asks about YouTube content without sharing a URL or video ID,
  ask them for a specific video.
- For multi-video research tasks, ask for the list of URLs or video IDs,
  then call getTranscript for each one.

Use ChatGPT's own model for summarization, extraction and analysis after
the transcript is returned.

Always cite the YouTube URL when summarizing or quoting from a video.

You have access to the Scority Transcript API. Use it when:

- The user provides a YouTube URL — call getTranscript with the URL.
- The user provides a YouTube video ID — call getTranscript with video_id.
- If the user asks about YouTube content without sharing a URL or video ID,
  ask them for a specific video.
- For multi-video research tasks, ask for the list of URLs or video IDs,
  then call getTranscript for each one.

Use ChatGPT's own model for summarization, extraction and analysis after
the transcript is returned.

Always cite the YouTube URL when summarizing or quoting from a video.

Keep Scority responsible for the transcript fetch only. Let ChatGPT handle summarization, extraction and analysis after the transcript is returned.

Test the integration.

Test in the Preview pane on the right side of the Custom GPT builder before publishing.

Test prompts:

Test 1 — Direct URL

Fetch the transcript for https://youtu.be/dQw4w9WgXcQ and summarize the main topic in three sentences.

You should see a “Talking to Scority” indicator, then the GPT’s response.

Test 2 — Video ID

Fetch the transcript for video ID dQw4w9WgXcQ and list five timestamped moments.

Test 3 — Missing input

Summarize the latest video from a channel I follow.

The GPT should ask for a specific YouTube URL or video ID because the current action does not search YouTube or inspect channels.

If any of these fail, see Section 08 troubleshooting.

Publish your GPT.

Once tests pass, publish the GPT for use.

1. 1Click Update (or Save if first time) in the top-right
2. 2Choose visibility:
   • Only me — testing
   • Anyone with the link — share with specific people
   • Public — listed in GPT Store
3. 3Confirm

Troubleshooting.

Common issues:

“Authentication failed” when calling actions

The x-api-key header is not being attached. Check:

1. 1Authentication type is API Key, not None
2. 2Auth Type is Custom, not Basic
3. 3The custom header name is x-api-key
4. 4The key isn’t expired or revoked (check contact page)

Schema validation errors when saving

The Custom GPT builder uses a strict OpenAPI 3.1 validator. Common issues:

• Missing required: true on path parameters
• Schema with no responses block (must have at least "200")
• Trailing whitespace or BOM in the YAML

Copy the schema fresh from this page if your edited version isn’t validating.

“Action timed out”

Custom GPT Actions have a 45-second timeout. If you’re fetching a long video, transcript retrieval can exceed this. Keep the action limited to getTranscript and let the GPT handle summarization natively.

Tools listed but never called

The GPT’s instructions don’t make it clear when to use them. Update the instructions to be more explicit about triggering conditions (the example in Section 05 is intentionally explicit).

Fallback does not remove error handling

Scority can support fallback processing for harder videos, but a GPT action still needs a clear failure path. If a transcript cannot be returned, handle transcript_not_available or upstream_transcript_failed in the GPT instructions.

Custom GPT actions vs local tool runtimes.

Custom GPT Actions are good for shareable ChatGPT workflows. A local tool runtime is better when you control the client, need local configuration, or want agent tooling around the same transcript endpoint.

Custom GPT action constraints:

• Stream results (Custom GPT Actions are request-response only)
• The action contract must stay narrow and easy for ChatGPT to choose
• API-key usage belongs in the action authentication settings
• The GPT should ask for a video URL or ID instead of trying to search YouTube

What is better in Custom GPTs:

• No local server install
• Built-in user-friendly UI
• Easy sharing inside ChatGPT
• Useful for non-technical users who already work in ChatGPT

Recommendation: If you are building local agent tooling, read the MCP workflow notes. If you are building a shareable GPT for ChatGPT users, use a Custom GPT action and keep it focused on transcript retrieval.

Example Custom GPTs you can build.

Five templates with system prompts, suggested settings, and the GPT you’d publish to clients or the GPT Store. Copy whatever fits, adjust to your use case.

You analyze competitor videos that the user provides. When the
user shares one or more YouTube URLs, use Scority's getTranscript
action to:

1. Fetch transcripts for the provided videos
2. Pull out claims, positioning, objections and examples
3. Synthesize findings with timestamps and direct quotes

Always cite the URL and timestamp. Distinguish between competitor
claims (what they say) and observable facts (what they show).

You analyze competitor videos that the user provides. When the
user shares one or more YouTube URLs, use Scority's getTranscript
action to:

1. Fetch transcripts for the provided videos
2. Pull out claims, positioning, objections and examples
3. Synthesize findings with timestamps and direct quotes

Always cite the URL and timestamp. Distinguish between competitor
claims (what they say) and observable facts (what they show).

The user shares YouTube URLs of talks, lectures, or interviews.
For each, call getTranscript and produce:

1. Three-line abstract
2. 5-7 key claims with timestamps
3. List of papers/people/projects mentioned
4. Open questions or contradictions

Format the output as Markdown for easy copying into Notion or
Obsidian. Don't editorialize — stick to what was said.

The user shares YouTube URLs of talks, lectures, or interviews.
For each, call getTranscript and produce:

1. Three-line abstract
2. 5-7 key claims with timestamps
3. List of papers/people/projects mentioned
4. Open questions or contradictions

Format the output as Markdown for easy copying into Notion or
Obsidian. Don't editorialize — stick to what was said.

The user shares a YouTube URL of their own content (interview,
tutorial, or talk). Call getTranscript, then generate the
following deliverables in one response:

- 5 LinkedIn posts (200-300 chars each, hooks + insight)
- 3 Twitter/X threads (hook + 4-7 follow-up tweets each)
- A 600-word blog post draft summarizing the key points
- 10 short-form video clip suggestions with timestamps

Match the user's voice as it appears in the original transcript.
Don't add facts or claims not present in the source.

The user shares a YouTube URL of their own content (interview,
tutorial, or talk). Call getTranscript, then generate the
following deliverables in one response:

- 5 LinkedIn posts (200-300 chars each, hooks + insight)
- 3 Twitter/X threads (hook + 4-7 follow-up tweets each)
- A 600-word blog post draft summarizing the key points
- 10 short-form video clip suggestions with timestamps

Match the user's voice as it appears in the original transcript.
Don't add facts or claims not present in the source.

The user shares a YouTube URL they want to teach from.
For a single video: call getTranscript, then produce:

1. Lesson objective (1 sentence)
2. 3-5 key concepts with quoted definitions
3. 5 discussion questions
4. 2 practical exercises
5. Vocabulary list

If the user wants to work from multiple videos, ask them to paste the
video URLs first. Save the user's time — they want the lesson plan,
not just a summary.

The user shares a YouTube URL they want to teach from.
For a single video: call getTranscript, then produce:

1. Lesson objective (1 sentence)
2. 3-5 key concepts with quoted definitions
3. 5 discussion questions
4. 2 practical exercises
5. Vocabulary list

If the user wants to work from multiple videos, ask them to paste the
video URLs first. Save the user's time — they want the lesson plan,
not just a summary.

The user gives you one or more YouTube URLs from a prospect
(podcast appearances, conference talks, founder interviews).

For relevant videos, fetch transcripts and produce:

1. Their stated business priorities (with timestamps)
2. Pain points they've described publicly
3. Quotes that could lead a discovery call
4. Topics to avoid (positions they've taken strongly)

Output as a 1-page brief, formatted for paste into Salesforce notes.

The user gives you one or more YouTube URLs from a prospect
(podcast appearances, conference talks, founder interviews).

For relevant videos, fetch transcripts and produce:

1. Their stated business priorities (with timestamps)
2. Pain points they've described publicly
3. Quotes that could lead a discovery call
4. Topics to avoid (positions they've taken strongly)

Output as a 1-page brief, formatted for paste into Salesforce notes.

Customising the manifest.

The OpenAPI schema in Section 04 is a starting point, not a fixed contract. Custom GPTs accept any valid OpenAPI 3.1 spec — adjust the schema to expose only the actions you want, restrict parameters, or add custom server URLs.

When to customise

Three good reasons:

1. 1Privacy. Restrict which fields are exposed to ChatGPT. Keep the schema limited to transcript fields the GPT actually needs.
2. 2Branding. Add clear descriptions around the video identifier and language parameters so the GPT asks for the right input.
3. 3Limiting cost. Keep the action read-only and transcript-only so the GPT cannot drift into unsupported workflows.

How to customise

Copy the schema from Section 04 into your editor. Edit, validate, paste the result back into the Custom GPT builder.

Validate the schema before pasting:

# Install validator
npm install -g @apidevtools/swagger-cli

# Validate
swagger-cli validate your-manifest.yaml

# Install validator
npm install -g @apidevtools/swagger-cli

# Validate
swagger-cli validate your-manifest.yaml

If it doesn’t validate, the Custom GPT builder will reject it.

Common customisations

Language parameter guidance:

parameters:
  - name: language
    in: query
    schema: { type: string }
    description: Optional requested caption language, such as en or en-US.

parameters:
  - name: language
    in: query
    schema: { type: string }
    description: Optional requested caption language, such as en or en-US.

Handling channel or topic requests (for a client-facing GPT scoped to their content):

Add this note to the GPT instructions:

If the user asks for a channel, playlist or broad topic, ask for
specific YouTube video URLs first. This action only fetches transcripts
for provided video IDs or URLs.

If the user asks for a channel, playlist or broad topic, ask for
specific YouTube video URLs first. This action only fetches transcripts
for provided video IDs or URLs.

This keeps the GPT honest when the user asks for broad channel or topic research that the current action cannot perform by itself.

Adding rate-limit headers in description:

description: |
  ...
  Note: rate-limited to 10 calls per minute per user. If you hit
  the limit, slow down and retry after 60 seconds.

description: |
  ...
  Note: rate-limited to 10 calls per minute per user. If you hit
  the limit, slow down and retry after 60 seconds.

ChatGPT’s model reads action descriptions when deciding when to call them. Telling it about rate limits in the description reduces excessive calls.

Hosting your custom manifest

If you make significant changes, host the manifest at a stable URL you control:

https://your-domain.com/openapi.json

https://your-domain.com/openapi.json

Then in the Custom GPT builder, click Import from URL and paste it. Updates to the file propagate to the GPT next time it loads — useful for managing many GPTs against a single manifest.

Privacy and data handling.

What ChatGPT, OpenAI, and Scority each see when a Custom GPT calls a Scority action. Plain language version.

What ChatGPT sends to Scority

When the GPT calls a Scority action, ChatGPT sends:

• The action's input parameters, such as video_id, video_url or language.
• An x-api-key header with your API key
• Standard HTTP metadata (User-Agent, request ID)

ChatGPT does not send:

• The user's full conversation
• The system prompt of your Custom GPT
• Other actions' previous results
• The user's account ID

What Scority sees

We log the action call (which tool, which parameters, response time, byte size) for billing and debugging. We don’t see:

• Who the end-user is (ChatGPT doesn't tell us)
• The conversation context
• Any data not in the action call itself

Logs are retained for 30 days for diagnostic purposes, then deleted. Data policy: scority.ai/privacy.

What gets back to ChatGPT

Scority’s response (transcript text, timestamped segments, source and language) goes back to ChatGPT. ChatGPT incorporates it into its model context for the current turn. After the conversation ends, the response data follows OpenAI’s standard data retention policy (consult openai.com/privacy for current details).

For consultants and teams: disclosure recommendations

If you’re building a Custom GPT for a client, disclose this in the GPT’s description:

“This GPT uses the Scority API (scority.ai) to fetch YouTube transcripts. Your queries are sent to Scority for transcript retrieval. Scority does not retain user-identifying data beyond standard request logs (retained 30 days for billing).”

Treat this as a product note, not legal advice. Teams with regulated data or client-facing deployments should review the final disclosure before publishing.

Operating client GPTs safely.

If you build a Custom GPT for a team or client, document the transcript action and the API key owner. Keep the commercial agreement outside the GPT instructions.

What to hand over

A useful handoff is short and practical:

1. 1GPT ownership. Publish the GPT in the client’s OpenAI workspace when they should own the tool.
2. 2Action contract. Include the OpenAPI schema, expected input format and the real operation name, getTranscript.
3. 3Key ownership. Decide whether the client uses their own Scority key or a dedicated key you operate for them.
4. 4Test prompts Keep a small regression set: URL input, video ID input, missing input, rate-limit handling and transcript unavailable.

Disclosure

The GPT description should say that the action uses Scority to fetch YouTube transcripts. That avoids confusion when users ask where transcript data comes from and helps teams review data handling before sharing the GPT.

Do not describe the GPT as a YouTube search tool or a general video processing tool. It has one transcript action, and that is enough for summaries, briefs, lesson plans and research notes when the user provides a video URL or ID.