- Brand
- Artlist
- Category
- Content & Design
- Primary Subcategory
- Multi-Modal Generative Media Platforms
Integration details
Description
Create images, videos, music, and voiceovers with leading AI models on Artlist, right inside ChatGPT. Start with an idea, add a reference image, and turn it into ready-to-use creative, plus find licensed music in the Artlist catalog without leaving your conversation With Artlist, you can: • Turn one image into a full campaign. Generate launch videos, ads, social content, and product visuals. • Create UGC and ads at scale. Generate authentic-looking product videos, reviews, walkthroughs, unboxings, tutorials, and more, with different hooks and formats ready to test. • Create lifestyle and retail visuals. Put your product in different settings, lifestyles, and contexts. Mock up compositions, lighting, and framing. • Create content for every market. Generate alternate visuals, voiceovers, and other assets adapted for different regions and audiences. • Bring your creative tools together. Use Artlist alongside other MCPs, so your tools and context work together in one workflow. Connect your Artlist account to get started.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Multi-Modal Generative Media Platforms
- Secondary Subcategories
- None listed
- Brand
- Artlist
- Access
- Account required
- First tracked
- 2026-10-09
- Tool count
- 32
- Geography
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Agent Discoverability
ChatGPT Plugin Discovery ScoreYour score is coming
ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.
What discovery looks like
Get alerts for Artlist
Get updates when Artlist’s Discoverability Score or category rank changes.
Competing in ChatGPT Multi-Modal Generative Media Platforms
View Category32 tools agents can invoke
Add an item to a style kit. `type: "text"` needs `content` (a free-text guideline, e.g. "cinematic lighting, teal and orange grade"). `type: "palette"` needs `colors` (1-50 `{hex, name?}` entries) — keep a kit to ONE palette item; add every color into it (via update_style_kit_item if it already exists) rather than creating a second, even if asked for a separate/named palette — not every client that can view a kit renders more than one. `type: "image"` needs exactly one of `input` (an existing asset — `{assetId}` from upload_image/confirm_upload — or a previous generation's output — `{generationId, outputIndex?}`) or `imageUrl` (a public https URL the server fetches). Image items process asynchronously — check get_style_kit until assetStatus is "ready" before relying on it in a generation. When adding several items, complete every addition first, then call get_style_kit once to show the final widget; do not wait for image processing.
add_style_kit_item
Artlist 3D generation. Supports text-to-3D from a prompt and image-to-3D from one input image. Image-to-3d: pass `input: { assetId }` (an uploaded image from upload_image / confirm_upload) or `input: { generationId, outputIndex? }` (a previous image generation) — ONE image only, no arrays; a prompt is optional. Text-to-3d: pass a `prompt` describing the object with no `input`. Optional `settings` (a single `quality` preset: low / medium / high, default medium) are validated against get_model_config; omitted keys use the model's defaults, echoed back as `resolvedSettings`. Returns { status: "queued", generationId } — immediately call get_generation_status; 3D models can take several minutes (deadline 540 s). The result is a textured GLB file with a preview image and extra download formats (OBJ / FBX / USDZ / …), not an image. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_3d_model
Artlist batch generation: several images and/or videos from one request, quoted and approved as one job. Use it whenever one request needs two or more generations with different prompts or inputs ("5 product shots", "ten stills and two clips") — never split such a request into separate generate_image/generate_video calls or several batches. For more takes of ONE prompt, use generate_image with settings.num_images instead. Each job takes the same arguments as generate_image or generate_video plus `type`. A batch holds at most a fixed number of jobs; over that it returns batch_too_large with maxJobs — then tell the user you can make at most that many in one go, and ask which to make first. Every job is checked and priced before any is created: if one is invalid it returns batch_invalid with each job's problem and nothing is spent. If it returns { status: "confirmation_required" }, nothing was spent: STOP, show the user the total (and how many generations it covers), and wait for their explicit approval in a new message — only then re-call with identical jobs plus confirmCost: true and approvedPrice set to that total. Never set confirmCost on your own. Otherwise it returns { status: "queued", jobs } with one outcome per job: queued (with generationId), failed (nothing charged), not_started (nothing charged) or unknown (may have been made and charged). Poll the queued generationIds with get_generation_status, at most 12 per call. Never resend a batch or an unknown job.
generate_batch
Create a complete brand/style kit for a named brand; use when the user says create style kit, brand kit, or visual identity. Create the kit, then add a practical palette, written style guidelines, and selective visual references in the same turn. First add the primary logo or wordmark from an official site, press/media page, or official social channel; official SVGs are supported and converted to PNG automatically. Also add meaningful logo variants that are readily available, such as light/dark, horizontal/stacked, or icon-only, without exhaustive research. Do not use campaign images, screenshots, stock imagery, search thumbnails, or logo-directory results in place of the primary logo. If no official logo is available after a quick check, use the most reliable exact public logo reference rather than asking the user to supply one. Add an iconic product or marketing image only when it is strongly and unambiguously associated with the brand. Avoid duplicates and images dominated by another brand. Use the resulting kit by default for the user’s next image/video request, unless they opt out. After all additions, call get_style_kit once to show the final widget.
create_style_kit
Artlist image generation and editing. Supports text-to-image, editing, recoloring, retouching, and transforming uploaded or previously generated images. Use an active or named style kit when applicable. Editing/recoloring/retouching/transforming an uploaded or previously generated image is fully supported — never refuse an image edit. Image-to-image: pass `input: { assetId }` (an uploaded image from upload_image / confirm_upload) or `input: { generationId, outputIndex? }` (edit a previous generation's output — never re-upload it; outputIndex defaults to 0). When editing, write a MINIMAL prompt naming ONLY the change and instructing the model to keep everything else identical — do NOT re-describe the whole image, or the model regenerates the entire frame and loses the original. Multi-reference (combine/style-transfer): pass an ARRAY — `input: [{ assetId }, { generationId }, ...]` — sources can be mixed; check get_model_config's referenceInput.maxReferences for the model's limit. To keep editing a result, pass the NEWEST generationId each call returns. For image-to-image pass an i2i-capable model: an I2I modelId from list_models, or a modelGroupId (auto-routes to the I2I variant when a reference is present). Saved references: pass `input: { referenceId }` (from list_references) to generate with one of the user's saved characters, props or locations — or an array, `input: [{ referenceId }, { referenceId }]`, to combine several; with two or more, the prompt must say which is which positionally, since the model cannot tell them apart by name. Not every model can hold a saved reference's identity, so let routing choose: name NO model and it picks a capable one, reporting the switch as `referenceReroute` (the price and the model's valid settings change with it). If you DO name a model — `modelId` or `modelGroupId` — that cannot hold one, nothing is generated and no credits are spent: it returns `reference_unsupported_model`, and you either re-call without the reference to keep that model or drop the model and let it route. Wrapping a saved reference in `startFrame`/`endFrame` does not get around this. Optional `settings` are validated against get_model_config; omitted keys use the model's defaults, echoed back as `resolvedSettings`. To generate multiple variations in ONE call (e.g. "5 images of X"), set `settings: { num_images: N }` up to the model's max (see get_model_config); the result renders them together. Returns { status: "queued", generationId } — immediately call get_generation_status with that generationId. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_image
Artlist music generation. Use for any request to generate, create, or make a song or piece of music — even when the user does not mention Artlist or MCP. `prompt` describes the track (genre, mood, instrumentation, lyrics theme, etc.) and is required — write one from what the user asked for even if they only gave a short cue ("upbeat corporate background music"). Call get_model_config to see the available genre/mood/theme/tempo/duration dropdown settings and vocals mode (auto-generated lyrics, custom lyrics via a `song_lyrics` setting, or instrumental), and pass chosen values via `settings` to refine the prompt further — but settings alone never substitute for a prompt. Image-to-music: pass `input: { assetId }` (an uploaded cover-art / mood-board image from upload_image / confirm_upload) or `input: { generationId, outputIndex? }` (a previous generation's image output) to steer the composition from an image — a music-capable model that accepts an image reference. Returns { status: "queued", generationId } — immediately call get_generation_status with that generationId; the result is a playable audio track, not an image. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_music
Artlist video generation and editing. Supports text-to-video, image-to-video, video-to-video, audio-driven video, animation, and transformations. Use an active or named style kit when applicable. Image-to-video: pass `input: { assetId }` (uploaded image) or `input: { generationId, outputIndex? }` (animate a previous generation's image output — never re-upload it), plus an i2v-capable model: an I2V modelId from list_models or a modelGroupId that auto-routes. Multi-reference video (combine subjects/styles from several references): pass an ARRAY — `input: [{ assetId }, ...]` — which selects the group's multi-reference variant (priced differently; the queued response echoes the price); check get_model_config's referenceInput.maxReferences. References can be images, videos, AND/OR audio: pass a video's assetId (from upload_video) for video-to-video / reference-to-video, an audio assetId (from upload_audio) for audio-driven / lipsync video, and mix any of them in the array freely (e.g. Seedance R2V, image + audio for a talking character). Use the uploaded video/audio directly — do NOT extract a frame or transcode. A video/audio reference needs a model that supports it (Seedance R2V is multi-to-video; the authority is get_model_config's videoReferenceInput / audioReferenceInput — pass its modelGroupId to auto-route). For audio-driven video, set `generate_audio: true` when get_model_config marks it supported. Start/end-frame interpolation: pass `input: { startFrame: ref, endFrame?: ref }` (each an image assetId or generationId) to interpolate between two frames; start alone is image-to-video, end requires start, and it needs a frames-capable model (get_model_config.frameInput). Draft mode: when get_model_config reports draftMode (Seedance 2.5), 480p makes a cheap draft that render_draft later renders in 1080p as the same take (within 7 days). Cost scales with `duration` — use the length the user asked for, or the model's default when they didn't say. Saved references: pass `input: { referenceId }` (from list_references) to animate one of the user's saved characters, props or locations — or an array, `input: [{ referenceId }, { referenceId }]`, to combine several; with two or more, the prompt must say which is which positionally, since the model cannot tell them apart by name. Not every model can hold a saved reference's identity, so let routing choose: name NO model and it picks a capable one, reporting the switch as `referenceReroute` (the price and the model's valid settings change with it). If you DO name a model — `modelId` or `modelGroupId` — that cannot hold one, nothing is generated and no credits are spent: it returns `reference_unsupported_model`, and you either re-call without the reference to keep that model or drop the model and let it route. Wrapping a saved reference in `startFrame`/`endFrame` does not get around this. Optional `settings` are validated against get_model_config; omitted keys use defaults. Returns { status: "queued", generationId } — immediately call get_generation_status; videos can take several minutes (deadline 540 s). If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_video
Create a custom voice from a recording of it, usable afterwards in generate_voiceover (text-to-speech only — cloned voices can’t be used for speech-to-speech). Needs an audio sample of the voice: get one with upload_widget (type: "audio") where the client supports it, otherwise upload_audio, and pass the returned assetId as `input: { assetId }`. At least 10 seconds of clear speech; `name` is what the user will see the voice called. Optional: `description`, `gender`, `previewLanguage` (the language of the preview clip the new voice reads back — the voice can still speak any supported language), `removeBackgroundNoise`. Cloning always costs credits and always requires approval: the first call returns { status: "confirmation_required" } with the cost and a consentStatement — STOP, show the user BOTH, and only after they explicitly approve in a new message re-call with confirmCost: true and consent: true. Never set either flag yourself. On approval it returns { status: "queued", generationId } — poll get_generation_status until it completes, then find the new voice with list_voices (custom: true).
clone_voice
Finalize a presigned upload: after PUTting the bytes to the uploadUrl from upload_image / upload_video / upload_audio, call this with the same `uploadId` and `mimeType`. Runs storage (and moderation, for images) and returns `{ assetId, ... }` — the durable handle for `input: { assetId }` in generate_image / generate_video. If the response has `urlPending: true` and no `url`, that is NOT a failure — generation works immediately from the assetId.
confirm_upload
Delete an item from a style kit.
delete_style_kit_item
Generate a voice-over in a chosen voice. Two modes, switched by input: text-to-speech (pass `text` to speak) or speech-to-speech (pass an audio `input` to re-voice a recording in the chosen voice — `input: { assetId }` from upload_audio, or `input: { generationId }` to re-voice a previous voice-over). First pick a voice with list_voices (present voices to the user by name/traits — never show any id), then pass its voiceId. For speech-to-speech the voice must be speech-to-speech-capable (find one with list_voices sts: true); cloned/custom voices are text-to-speech only, and any text is ignored when an audio input is present. Optionally call get_model_config with that voiceId to see the language / accent / emotion / speed options the voice supports, and pass chosen values via `settings` (omitted keys use the voice’s defaults). Omit modelId/modelGroupId to auto-route to the voice-over model; a voiceId that the pinned model can’t use is rejected in plain language. Returns { status: "queued", generationId } — immediately call get_generation_status with that generationId until it completes. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost, and only re-call with confirmCost: true after they explicitly approve. Never set confirmCost on your own.
generate_voiceover
Look up full details for one or more Artlist music tracks by songId, taken from a search_music result. Returns title, artist, duration, tempo, genres and a preview audio URL, plus — on request — separated stems, similar tracks, or the song's other versions. Pass includeSimilar: true for "more like this"; includeVersions: true when the user asks what versions exist. This tool cannot download — send the user to the returned artlist.io link.
get_track
Get the user's plan and remaining AI credits — or, for users without an AI-credit plan, their remaining one-time free generations. Call when the user asks about their credits, balance, plan, or how many more generations they can make. Read-only. Present the values conversationally ("You have 120 credits left"), never as a raw dump; if the result says the balance is unavailable, say you couldn't check right now and offer to try again shortly.
get_balance
Get the exact credit cost for a planned image, video, music, 3D model, or voice-over generation — or for rendering a Seedance 2.5 draft in 1080p (kind "draftRender" + generationId) — without starting it. Pass the same kind, prompt or text, modelId/modelGroupId, settings, and reference input you would use for the matching generate tool; use get_model_config for settings and list_models for a model. This is a read-only price quote — it never creates a generation. Call it whenever the user asks how many credits a generation will use; do not estimate from static sources. If the user then asks to generate, call the matching generate tool, which performs a fresh quote and its normal confirmation gate.
get_generation_cost
Check whether a generation has finished and get the result — pass one generationId, or an array of several to monitor them together (for example, one per style kit) instead of calling this tool separately for each. Blocks up to ~50 s waiting for completion, then returns immediately. If status is "pending", call again immediately with the same argument — do not sleep between calls; for an array, pass the exact same array again, even once some of its ids have individually completed. A single generationId returns its own result widget once done. An array stays quiet (no widget, no individual result cards) until every id in it reaches a final state, then returns one combined gallery so no result is lost when the host collapses repeated status cards. When completed, returns the image inline (small results) or a file URL; for a 3D model it returns the GLB URL, a `formats` list with per-format download links, and the preview thumbnail inline.
get_generation_status
Get a model's configurable settings — keys, allowed values, defaults, required flags — for a `modelId` or `modelGroupId` from list_models. Call before generating; pass chosen values via `settings`. Media inputs (reference images) go through the generate tools' `input` argument, not settings. Voice-over: pass a `voiceId` from list_voices to narrow the language / accent / emotion / speed options to what that voice supports. `draftMode: true` means the model's 480p resolution makes a draft that render_draft can later render in 1080p.
get_model_config
Fetch the reference(s) the user just uploaded through the upload panel (upload_widget), as assetId(s). Call this as soon as the user’s message says they uploaded / added / attached a file via the panel — the panel cannot pass the assetId to you any other way, so without this call you have nothing to generate from. Optional `kind` narrows to "image" | "video" | "audio". Returns { status: "ok", uploads: [{ assetId, kind, fileName?, uploadedSecondsAgo }], routing } newest-first — follow `routing` to the right tool for each kind, and never show an assetId to the user. If it returns { status: "no_recent_uploads" }, the panel upload did not finish: ask the user to pick the file again, or fall back to upload_image / upload_video / upload_audio.
get_recent_uploads
List the user's recent generations (paginated). Use to find a past result to show or iterate on.
list_generations
List available generation models with ids, names, and features. `kind`: "image" (default), "video", "voice" (voice-over models), "music", or "model3d" (3D model generation). Optional `feature` filter: "text-to-image" | "image-to-image" | "text-to-video" | "image-to-video" | "multi-to-video" | "text-to-speech" | "speech-to-speech" | "voice-cloning" | "text-to-music" | "image-to-music" | "image-to-3d" | "text-to-3d". Use to resolve a model the user named, find an i2i/i2v/multi-reference-capable model, a text-to-speech / speech-to-speech voice-over model, a music model, or an image-to-3d / text-to-3d model, or answer what's available.
list_models
List the user's saved references — reusable characters, props and locations they created in Artlist Toolkit — so one can be used in an image or video generation. Call this whenever the user names one ("use Emma", "my sword prop", "that cave location", "the character I made") or asks which references they have. Optional `type` narrows to "character", "prop" or "location"; optional `name` filters by a case-insensitive substring. Each result returns the reference's name and type plus an inline picture of it; `previewIndex` gives the position of that picture among the images returned alongside the JSON. Present them to the user by name and picture and let them choose — NEVER show the id, and never pick one for them when several match. To generate with the chosen reference, pass `input: { referenceId }` to generate_image or generate_video (an array of them to combine several in one generation).
list_references
List the user's saved style kits (name, id, item count). A style kit bundles reference images, text guidelines, and color palettes that can be applied to a generation via generate_image/generate_video's `styleKitId`. Call this when the user wants to generate with a style/brand kit or asks what kits they have.
list_style_kits
List voice-over voices (identities) to choose from before generating a voice-over. Library voices by default; `custom: true` for the user's own cloned voices. Optional filters: `modelGroupId` (only voices usable by that voice model group), `gender` (MALE / FEMALE / NEUTRAL), `sts: true` (speech-to-speech-capable voices), `query` (name match). Each voice returns name, gender, age, languages, accents, and a preview URL. Present voices by name and traits; never show voiceId or any id to the user.
list_voices
Open Artlist’s in-chat upload panel as a FALLBACK for a file on the user’s DEVICE, when the direct upload_image / upload_video / upload_audio can’t complete in this client (the byte-upload is blocked — e.g. a sandboxed host whose egress can’t reach the upload URL). Prefer the direct upload tools first; open this panel only as a fallback when that path fails or the client can’t deliver the bytes. The user picks and uploads in the panel (it uploads straight from their browser). The panel NEVER tells you the assetId directly: the moment the user’s next message says they uploaded something, call get_recent_uploads to fetch the confirmed assetId(s), then generate IMMEDIATELY with them without asking anything further or re-confirming the request. `type` restricts what they can pick (default auto — image, video, or audio), `maxFiles` (default 1) allows several references at once for multi-reference models, `label` titles the panel (e.g. "Add your voice sample"). In clients without interactive panels (Claude Code / Cursor), use upload_image / upload_video / upload_audio.
upload_widget
Internal — used by the upload panel to hand its confirmed uploads to the server. Do not call this; read uploads with get_recent_uploads instead.
record_uploads
Render a Seedance 2.5 draft video (a 480p generation) in full 1080p. This continues the SAME take at higher quality rather than generating a new one; the draft's prompt, settings and references are reused, so pass only the draft's generationId (plus outputIndex for a multi-output generation). Only drafts can be rendered, and only within 7 days of creation: get_generation_status reports `drafts[].renderableUntil` on a draft. Charges the normal 1080p price. Returns { status: "queued", generationId } — immediately call get_generation_status with the NEW generationId. If it returns { status: "confirmation_required" }, no credits were spent: show the user the cost and wait for their explicit approval, then re-call with confirmCost: true. On draft_unavailable, generate the video again at 1080p with generate_video instead; on reference_expired, tell the user the uploaded file must be uploaded again. On render_failed, tell the user the returned message.
render_draft
Search the Artlist stock sound-effect catalog for clips that already exist. Results are ordered like artlist.io by default (Staff Picks) — do NOT pass sortBy unless the user asks for newest or most popular. Supports free-text search (what the sound should be — "glass breaking", "footsteps on gravel", "whoosh transition"); refine a search further with categoryIds or tags, but only using values copied from a previous result's `categories` or `suggestedTags` fields — never invent one. Returns title, a preview audio URL, a link to the clip on artlist.io, a link to the SFX pack the clip belongs to (packUrl, null when it has none), and curator-suggested tags for refining the search further. This tool always plays the ENTIRE clip — unlike music, sound effects have no highlight/preview window. Use this to find or browse catalog sound effects. This tool does not download — send the user to the returned artlist.io link.
search_sfx
Search the Artlist stock music catalog for tracks that already exist. Results are ordered like artlist.io by default (Staff Picks) — do NOT pass sortBy unless the user asks for newest or most popular. Supports free-text search (mood, genre, instrument, artist, lyric fragment), vocal type, BPM range, duration range, genre categories, and a stems-only filter. Returns title, artist, duration, tempo, a preview audio URL and a link to the track on artlist.io. Use this to find, browse or discover catalog music. To create NEW music from a prompt instead, use generate_music. This tool does not download — send the user to the returned artlist.io link.
search_music
Update a style kit item's `name` or `content` (at least one required). An image item's content cannot be changed — delete it and add a new one instead.
update_style_kit_item
Store a user-provided audio file and get a durable `assetId` back. Two modes: (1) pass `audioUrl` (a public https URL) — the server fetches and stores it; (2) pass `mimeType` (+ the user's real `fileName` whenever you know it — it names the asset and any generation made from it) to get a presigned `uploadUrl` + `uploadId` — PUT the file bytes to that URL (e.g. with curl), then call confirm_upload. Supported formats: MP3, WAV, M4A/AAC, OGG. Never send base64 data. Returns an `assetId` with two uses: (1) re-voice the recording in another voice (speech-to-speech) — pass `input: { assetId }` to generate_voiceover together with a speech-to-speech-capable voiceId from list_voices `sts: true`; (2) drive a video (audio-driven / lipsync) — pass `input: { assetId }` to generate_video (or mixed with image/video references in an array) with an audio-capable model (e.g. Seedance R2V-with-audio). If the user has a file on their DEVICE and this upload can’t complete in their client (the byte-upload is blocked, as in some sandboxed hosts), call upload_widget as a fallback — it opens an in-chat panel that uploads straight from the user’s browser.
upload_audio
Make a user-provided image usable as a generation reference. Two modes: (1) pass `imageUrl` (a public https URL) — the server fetches, moderates, and stores it; (2) pass `mimeType` (+ the user's real `fileName` whenever you know it — it names the asset and any generation made from it) to get a presigned `uploadUrl` + `uploadId` — PUT the file bytes to that URL (e.g. with curl), then call confirm_upload. Never send base64 image data. Returns an `assetId` to pass as `input: { assetId }` to generate_image / generate_video. Not for generated outputs — pass `input: { generationId }` to the generate tools instead. If the user has a file on their DEVICE and this upload can’t complete in their client (the byte-upload is blocked, as in some sandboxed hosts), call upload_widget as a fallback — it opens an in-chat panel that uploads straight from the user’s browser.
upload_image
Store a user-provided video and get a durable `assetId` back. Two modes: (1) pass `videoUrl` (a public https URL) — the server fetches and stores it; (2) pass `mimeType` (+ the user's real `fileName` whenever you know it — it names the asset and any generation made from it) to get a presigned `uploadUrl` + `uploadId` — PUT the file bytes to that URL (e.g. with curl), then call confirm_upload. Supported formats: MP4, MOV, WebM. Never send base64 data. Returns an `assetId` — use it directly as a video reference in generate_video via `input: { assetId }` (or mix with image references in an array) for video-to-video / reference-to-video. Do NOT extract a frame from the video — pass the video itself. If the user has a file on their DEVICE and this upload can’t complete in their client (the byte-upload is blocked, as in some sandboxed hosts), call upload_widget as a fallback — it opens an in-chat panel that uploads straight from the user’s browser.
upload_video
View a style kit's full contents: its text guidelines, color palettes, and image items (with each image's readiness status and, once ready, a preview URL). Use this to show the user what's in a kit, or to check whether a just-added image has finished processing (assetStatus: "pending" → "ready").
get_style_kit
Recommended guideHow to get your ChatGPT Plugin suggestedFollow the practical steps agents use to find, shortlist, and choose your Plugin.Read guideArtlist ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Artlist's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Artlist alternatives on ChatGPT?
As of 2026-10-09, Artlist competes with Ad Army, Arcads, Atlas Cloud, Carat, Clipwave Video & Image Maker, Creative Claw, Deep Art AI, fal and 18 more in ChatGPT Multi-Modal Generative Media Platforms, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.