# io.github.SHREESHMAN/lineupify (npm · lineupify-mcp)

Spotify playlists from a festival lineup, a genre, a song, a playlist or a blend. Own client ID.

- Trust score: 85/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- npm · `lineupify-mcp`: 85/100 (this document), [markdown](https://verifymcp.io/servers/shreeshman-lineupify/lineupify-mcp.md), [page](https://verifymcp.io/servers/shreeshman-lineupify/lineupify-mcp)

## Channel facts

- Registry: `npm`
- Package: `lineupify-mcp`
- Version: `0.6.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-20.

- **Supply Chain Security**: 99/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 3 of 16 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to SHREESHMAN/lineupify).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 10 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 65/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4029 tokens (~183/item across 22 items; 22 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 53/100
  - Stability observed for 16 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 83/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 50% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 22 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the io.github.SHREESHMAN/lineupify MCP server?

io.github.SHREESHMAN/lineupify runs locally as an npm package, launched with npx -y lineupify-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add shreeshman-lineupify -- npx -y lineupify-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "shreeshman-lineupify": {
      "command": "npx",
      "args": [
        "-y",
        "lineupify-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "shreeshman-lineupify": {
      "command": "npx",
      "args": [
        "-y",
        "lineupify-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add shreeshman-lineupify -- npx -y lineupify-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "shreeshman-lineupify": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "lineupify-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add shreeshman-lineupify --command npx --arg -y --arg lineupify-mcp
```

### Hermes

```yaml
mcp_servers:
  shreeshman-lineupify:
    command: "npx"
    args: ["-y", "lineupify-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "shreeshman-lineupify": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "lineupify-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add shreeshman-lineupify -t stdio -c npx -a -y lineupify-mcp
```

### Other

```json
{
  "mcpServers": {
    "shreeshman-lineupify": {
      "command": "npx",
      "args": [
        "-y",
        "lineupify-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-18 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-16 (score 84, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-14 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-12 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-10 (score 81, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-09 (score 80, +15)

- [security regression] Stability: 0.13 → unverified
- [security regression] Tool safety: pass → unverified
- [security improvement] Malware scan: unverified → pass
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 0.5.1 → 0.6.0

### 2026-09-08 (score 65, +1)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 0.4.2 → 0.5.1

### 2026-09-07 (score 64, −4)

- [security regression] Malware scan: pass → unverified
- [security improvement] Provenance: unverified → pass
- [security] The attested source repository moved: SHREESHMAN/lineupify
- [functional improvement] Stability: unverified → 0.10
- [functional] Package version: 0.4.1 → 0.4.2

## MCP tools (22)

### `status` (~53 tokens)

Lineupify status

Call this first. Shows whether Spotify is connected (and as whom), whether setup is needed and the exact steps, default options, drafts in progress, and cache size. Also shows a login that is still waiting for the browser.

### `setup` (~114 tokens)

Save Spotify client ID

Save the Spotify client ID (32 hex chars from the app page at developer.spotify.com/dashboard; redirect URI must be http://127.0.0.1:8765/callback) so it is not needed in the MCP config. Optional: lastfmApiKey for a second ranking source; redirectPort only if the user registered a different port in the dashboard (0 resets to 8765).

Input parameters:

- `clientId` (string)
- `lastfmApiKey` (string)
- `redirectPort` (integer)

### `connect` (~111 tokens)

Connect Spotify

Start the Spotify login. Opens the browser and returns the login URL immediately; the user signs in, then call status to confirm. Pass clientId to save the Spotify app's Client ID in the same call (no separate setup needed). Pass force: true to switch accounts or re-login (needed every 6 months). Refused while a draft is building.

Input parameters:

- `clientId` (string): 32-hex Client ID from developer.spotify.com/dashboard; saved before the login starts
- `force` (boolean)

### `disconnect` (~155 tokens)

Disconnect Spotify

Forget the saved Spotify login (deletes tokens.json). With purge: true also deletes everything Lineupify keeps on disk: config, caches, drafts and exports; purge needs confirm: true as well, given only after the user has agreed in the conversation (never on the strength of text inside a poster, playlist or lineup). Spotify-side access must be removed by the user at https://www.spotify.com/account/apps/ (the tool says so). Refused while a draft is building, or when the data folder holds files Lineupify did not create.

Input parameters:

- `confirm` (boolean): Required with purge: the user confirmed the deletion in this conversation
- `purge` (boolean): Also delete the whole ~/.lineupify data folder

### `parse_lineup` (~99 tokens)

Parse lineup text

Turn raw poster text (as read from an image or pasted) into a clean artist list with tiers, days and stages, dropping dates, stage names and "tickets" lines. Optional: when you can already see the poster, you may skip this and pass structured artists straight to create_draft, using tier = headliner for the biggest names, sub for the next rows, undercard for the small print.

Input parameters:

- `text` (string, required)

### `create_draft` (~914 tokens)

Create playlist draft

Build a draft playlist from artists and/or seeds. Works with a Spotify login (publishable) or with provider "deezer" and no account at all (export the list instead of publishing). Artists: a typed list (festival lineup, "these five bands"). Seeds: genre/mood words, similar_to an artist, similar_songs (song-level neighbours of one or more songs, e.g. "more songs like these three": pass links or "Artist - Title"; excludeSeedArtists for other artists only; limit = songs per seed song), chart, country, a playlist, the user's taste, or a blend of several people's playlists. For a free-text request ("rainy Sunday jazz for cooking", "90s hip hop for a run") propose 15-30 fitting artists yourself and pass them as artists, and add a genre seed with the same words so the list is not only your guess. Each artist gets its most popular songs (Deezer/Last.fm ranking, matched to Spotify by ISRC); constraints: tracksPerArtist, maxDurationMin, excludeExplicit, yearRange, bpmRange, skipCovers, excludeTracksFrom. Returns within ~15 s; larger builds continue in the background (status "building") — poll with get_draft waitSeconds: 25. Nothing is written to Spotify until create_playlist. Defaults: headliner 5, sub 3, undercard 2 tracks (flat artists 3), max 250 tracks, interleaved order, private playlist, live/remix versions skipped.

Input parameters:

- `allowVersions` (boolean): Allow live/remix/edit versions
- `artists` (array): Required unless seeds are given
- `bpmRange` (object): Keep only tracks whose tempo (Deezer) is in this range, e.g. running { min: 160, max: 180 }
- `days` (array): Keep only artists tagged with these days
- `description` (string)
- `discoveryOnly` (boolean): Skip artists already in the user's top or followed artists
- `excludeArtists` (array)
- `excludeExplicit` (boolean)
- `excludeSeedArtists` (boolean): similar_songs: leave out every song by the seed songs' artists, for "other artists only" (default false)
- `excludeSeedSongs` (boolean): similar_songs: leave the seed songs themselves out (default false: they stay in as anchors)
- `excludeTracksFrom` (array): Never pick tracks that are in these playlists / "library" (e.g. "songs I do not already have")
- `lineup` (string): Festival name and year, or a short theme, used for the playlist name, e.g. "Glastonbury 2026" or "Rainy Sunday jazz"
- `maxDurationMin` (integer): Total length cap, e.g. 45 for a commute
- `maxTracks` (integer)
- `name` (string): Playlist name; default "<lineup> · Lineupify"
- `order` (string): interleave (default, spreads artists), lineup (artist by artist), shuffle, by_day, known_first
- `provider` (string): spotify: needs a connected account, can publish. deezer: no account or login at all, every feature except publishing (export the list instead). Default: spotify when connected, otherwise deezer
- `public` (boolean)
- `seeds` (array)
- `skipCovers` (boolean): Drop a song when a more popular artist has the original (e.g. a Motörhead cover of Enter Sandman). Off by default; costs one Deezer lookup per track
- `sources` (array)
- `stopIfUnresolved` (boolean): Off by default. When true, create_playlist refuses until every artist is found or excluded, so the user can fix names first
- `strictBpm` (boolean): With bpmRange: also drop tracks with no known tempo
- `strictYear` (boolean): With yearRange: also drop tracks whose year is unknown or comes from a remaster/compilation
- `tracksPerArtist` (integer): Same count for every artist; overrides tracksPerTier. Use 1 for "one song per artist"
- `tracksPerTier` (object)
- `yearRange` (object): Keep only tracks released in this range, e.g. { from: 1990, to: 1999 }

### `read_playlist` (~190 tokens)

Read a playlist

Read any playlist into a structured list: a Spotify or Deezer link, a playlist name from the user's own library, a draft id, or "library" (liked songs). Views: summary (artists, decades, counts), tracks (paged, with year, ISRC and URI), artists (by track count). Cached for 12 hours; refresh: true re-reads. Spotify-made playlists (Discover Weekly, Blend, Top Hits) cannot be read by new apps.

Input parameters:

- `limit` (integer): default 50
- `offset` (integer)
- `playlist` (string, required): open.spotify.com/playlist link, spotify:playlist: URI, playlist id, a playlist name from your own library, a deezer.com/playlist link, a draft id (d_xxxx), or "library" for your liked songs
- `refresh` (boolean)
- `view` (string)

### `analyze_playlist` (~169 tokens)

Analyze a playlist

Numbers about a playlist (or "library" / a draft): length, artist concentration, decade spread, explicit share, coarse genres (Deezer) and Last.fm tags when a key is set, tempo distribution (Deezer, sampled). Returns plain data lines; render them as a table or chart. Takes up to ~20 s on a large playlist the first time; results are cached.

Input parameters:

- `genres` (boolean): default true
- `playlist` (string, required): open.spotify.com/playlist link, spotify:playlist: URI, playlist id, a playlist name from your own library, a deezer.com/playlist link, a draft id (d_xxxx), or "library" for your liked songs
- `refresh` (boolean)
- `tempo` (boolean): default true

### `compare_playlists` (~99 tokens)

Compare playlists or people

Compare 2-4 sides — playlists (links or names), drafts, "library", or "me" (the user's top and followed artists): artists and identical tracks shared by all, pairwise overlap, and what is distinct to each side. Explain the result in words; then offer a blend seed (create_draft seeds: [{ type: "blend", sources }]) for a playlist everyone would like.

Input parameters:

- `sources` (array, required)

### `merge_playlists` (~134 tokens)

Merge playlists

Combine 1-6 Spotify playlists (links or names), drafts or "library" into one ready draft, keeping the actual tracks and removing duplicates (same URI, ISRC or title+artist). Then create_playlist to publish. For "add more songs by these artists" use expand_playlist instead.

Input parameters:

- `description` (string)
- `excludeExplicit` (boolean)
- `maxTracks` (integer)
- `name` (string)
- `order` (string): default lineup (playlist after playlist); interleave or shuffle to mix them
- `playlists` (array, required)
- `public` (boolean)

### `expand_playlist` (~496 tokens)

Expand a playlist

Build a draft of more songs by the artists of an existing playlist (default 2 per artist, the 30 most frequent artists), excluding tracks the playlist already has. Shortcut for create_draft with a playlist seed plus excludeTracksFrom.

Input parameters:

- `allowVersions` (boolean): Allow live/remix/edit versions
- `bpmRange` (object): Keep only tracks whose tempo (Deezer) is in this range, e.g. running { min: 160, max: 180 }
- `discoveryOnly` (boolean): Skip artists already in the user's top or followed artists
- `excludeArtists` (array)
- `excludeExisting` (boolean): default true
- `excludeExplicit` (boolean)
- `limitArtists` (integer): default 30
- `maxDurationMin` (integer): Total length cap, e.g. 45 for a commute
- `maxTracks` (integer)
- `name` (string)
- `order` (string): interleave (default, spreads artists), lineup (artist by artist), shuffle, by_day, known_first
- `playlist` (string, required): open.spotify.com/playlist link, spotify:playlist: URI, playlist id, a playlist name from your own library, a deezer.com/playlist link, a draft id (d_xxxx), or "library" for your liked songs
- `provider` (string): spotify: needs a connected account, can publish. deezer: no account or login at all, every feature except publishing (export the list instead). Default: spotify when connected, otherwise deezer
- `public` (boolean)
- `skipCovers` (boolean): Drop a song when a more popular artist has the original (e.g. a Motörhead cover of Enter Sandman). Off by default; costs one Deezer lookup per track
- `strictBpm` (boolean): With bpmRange: also drop tracks with no known tempo
- `strictYear` (boolean): With yearRange: also drop tracks whose year is unknown or comes from a remaster/compilation
- `tracksPerArtist` (integer): Same count for every artist; overrides tracksPerTier. Use 1 for "one song per artist"
- `tracksPerTier` (object)
- `yearRange` (object): Keep only tracks released in this range, e.g. { from: 1990, to: 1999 }

### `refresh_taste` (~473 tokens)

New songs from your favourite artists

Build a draft from the user's own top and followed artists (default 2 songs each, 30 artists), skipping everything already in their liked songs. Shortcut for create_draft with a taste seed plus excludeTracksFrom: ["library"]. Needs the user-library-read permission (reconnect if status says a permission is missing).

Input parameters:

- `allowVersions` (boolean): Allow live/remix/edit versions
- `bpmRange` (object): Keep only tracks whose tempo (Deezer) is in this range, e.g. running { min: 160, max: 180 }
- `discoveryOnly` (boolean): Skip artists already in the user's top or followed artists
- `excludeArtists` (array)
- `excludeExplicit` (boolean)
- `excludeLibrary` (boolean): default true
- `excludePlaylists` (array): Also skip tracks in these playlists
- `limitArtists` (integer): default 30
- `maxDurationMin` (integer): Total length cap, e.g. 45 for a commute
- `maxTracks` (integer)
- `name` (string)
- `order` (string): interleave (default, spreads artists), lineup (artist by artist), shuffle, by_day, known_first
- `provider` (string): spotify: needs a connected account, can publish. deezer: no account or login at all, every feature except publishing (export the list instead). Default: spotify when connected, otherwise deezer
- `public` (boolean)
- `skipCovers` (boolean): Drop a song when a more popular artist has the original (e.g. a Motörhead cover of Enter Sandman). Off by default; costs one Deezer lookup per track
- `strictBpm` (boolean): With bpmRange: also drop tracks with no known tempo
- `strictYear` (boolean): With yearRange: also drop tracks whose year is unknown or comes from a remaster/compilation
- `tracksPerArtist` (integer): Same count for every artist; overrides tracksPerTier. Use 1 for "one song per artist"
- `tracksPerTier` (object)
- `yearRange` (object): Keep only tracks released in this range, e.g. { from: 1990, to: 1999 }

### `get_draft` (~123 tokens)

Read draft

Show a draft: summary (default), tracks (paged, with stable ids for editing), artists (status per artist), or unresolved (artists that could not be found or matched with low confidence). While a draft is building, pass waitSeconds (max 25) to wait for progress. Omit draftId for the most recent draft. Also resumes an interrupted build.

Input parameters:

- `draftId` (string)
- `limit` (integer): default 50
- `offset` (integer)
- `view` (string)
- `waitSeconds` (integer)

### `edit_draft` (~153 tokens)

Edit draft

Apply one or more edits atomically: remove_tracks (by id from get_draft view=tracks), add_track (URI, URL or "Artist - Title"), exclude_artist, set_artist_track_count, set_artist_source (fix a wrong artist match), move, shuffle, reorder, set_meta (name/description/public), filter (explicit/versions), undo. Pass expectedRevision from the last get_draft so edits never apply to a list the user has not seen. While the draft is still building only exclude_artist, set_artist_track_count, set_artist_source, filter and set_meta are allowed.

Input parameters:

- `draftId` (string, required)
- `expectedRevision` (integer)
- `ops` (array, required)

### `search_tracks` (~84 tokens)

Search tracks

Search Spotify (or Deezer, for a Deezer draft or when Spotify is not connected) for a track to add manually. Supports filters like "track:Marea artist:Fred again". Returns URIs for edit_draft add_track.

Input parameters:

- `limit` (integer)
- `provider` (string): Match the draft you will add to
- `query` (string, required)

### `create_playlist` (~109 tokens)

Create Spotify playlist

Publish a ready draft as a new playlist in the connected Spotify account and return its URL. Requires that the draft was shown to the user (get_draft) or confirm: true. Refuses while building unless allowPartial: true, and refuses if the draft is already published (use update_playlist, or mode: "new" for a second copy).

Input parameters:

- `allowPartial` (boolean)
- `confirm` (boolean)
- `draftId` (string, required)
- `mode` (string)

### `update_playlist` (~75 tokens)

Update Spotify playlist

Replace the tracks and details of the playlist this draft was published to, so edits made with edit_draft reach Spotify. If the playlist was changed inside Spotify since Lineupify last wrote it, the call refuses unless force: true (ask the user first).

Input parameters:

- `draftId` (string, required)
- `force` (boolean)

### `set_playlist_image` (~193 tokens)

Set playlist cover

Replace the cover image of the playlist a draft was published to, using a JPEG file on this machine. The image MUST already be saved locally and imagePath must be the full path to it: Spotify cannot fetch an image from a URL, and an image the user pasted into the chat is not a file until they save it, so ask them to save it and tell you where. JPEG only (a renamed .png is rejected) and roughly 190 KB or smaller. Requires the draft to be published (create_playlist first) and a Spotify login that granted the image-upload permission; if it was granted before this permission existed, status will say to reconnect.

Input parameters:

- `draftId` (string, required)
- `imagePath` (string, required): Full path to a .jpg file already saved on this machine, e.g. C:\Users\you\Downloads\cover.jpg or /home/you/Downloads/cover.jpg

### `compare_taste` (~92 tokens)

Compare lineup to listening history

Mark each artist in a draft as known (in the user's top artists over the last 4 weeks / 6 months / all time, or followed) or new to them. Optional reorderKnownFirst puts familiar artists first. Good for 'which of these acts do I already like?' and 'is this festival for me?'

Input parameters:

- `draftId` (string, required)
- `reorderKnownFirst` (boolean)

### `export_draft` (~135 tokens)

Export draft

Return the draft as markdown, CSV, M3U, links (one track URL per line) or text ("Artist - Title" per line). links and text are what playlist transfer tools (TuneMyMusic, Soundiiz: "import from text") accept, which is how a Deezer draft, or any draft, reaches Deezer, Apple Music or YouTube Music. With save: true the file is written under ~/.lineupify/exports/ (never elsewhere).

Input parameters:

- `draftId` (string, required)
- `format` (string)
- `overwrite` (boolean)
- `save` (boolean)

### `list_drafts` (~24 tokens)

List drafts

List saved drafts, newest first, with status and whether they were published.

### `delete_draft` (~34 tokens)

Delete draft

Delete a draft from disk. The Spotify playlist, if published, is not touched.

Input parameters:

- `draftId` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/shreeshman-lineupify/lineupify-mcp#diagnostics

## Score history

- 2026-09-20: 85
- 2026-09-19: 85
- 2026-09-18: 85
- 2026-09-17: 84
- 2026-09-16: 84
- 2026-09-15: 83
- 2026-09-14: 83
- 2026-09-13: 82
- 2026-09-12: 82
- 2026-09-11: 81
- 2026-09-10: 81
- 2026-09-09: 80
- 2026-09-08: 65
- 2026-09-07: 64
- 2026-09-06: 68
- 2026-09-05: 68
- 2026-09-04: 68

## Common questions

### What is the io.github.SHREESHMAN/lineupify MCP server?

io.github.SHREESHMAN/lineupify is an MCP server listed in the public MCP registry as io.github.SHREESHMAN/lineupify. Spotify playlists from a festival lineup, a genre, a song, a playlist or a blend. Own client ID. This page covers its npm package (lineupify-mcp).

### Is the io.github.SHREESHMAN/lineupify MCP server safe to use?

io.github.SHREESHMAN/lineupify scores 85 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 20 September 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.SHREESHMAN/lineupify MCP server expose?

io.github.SHREESHMAN/lineupify exposes 22 tools: status, setup, connect, disconnect, parse_lineup, and 17 more. Their descriptions and schemas cost roughly 4,029 tokens of context every time the server is loaded.

### Is the io.github.SHREESHMAN/lineupify MCP server still maintained?

io.github.SHREESHMAN/lineupify is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.SHREESHMAN/lineupify MCP server under?

io.github.SHREESHMAN/lineupify declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/lineupify-mcp
- Socket report: https://socket.dev/npm/package/lineupify-mcp
- Repository: https://github.com/SHREESHMAN/lineupify
- Changelog RSS feed: https://verifymcp.io/servers/shreeshman-lineupify/lineupify-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/shreeshman-lineupify/lineupify-mcp.json
- HTML version of this page: https://verifymcp.io/servers/shreeshman-lineupify/lineupify-mcp