Github

Accepts a pending repository invitation that has been issued to the authenticated user.

Deprecated: lists repositories starred by the authenticated user, including star creation timestamps; use 'list repositories starred by the authenticated user' instead.

Deprecated: lists users who have starred a repository; use `list stargazers` instead.

Deprecated: stars a repository for the authenticated user; use `star a repository for the authenticated user` instead.

Replaces github app access restrictions for an existing protected branch; requires a json array of app slugs in the request body, where apps must be installed and have 'contents' write permissions.

Adds or removes assignees for a github issue; changes are silently ignored if the authenticated user lacks push access to the repository.

Adds a github user as a repository collaborator, or updates their permission if already a collaborator; `permission` applies to organization-owned repositories (personal ones default to 'push' and ignore this field), and an invitation may be created or permissions updated directly.

Adds a repository to a github app installation, granting the app access; requires authenticated user to have admin rights for the repository and access to the installation.

Designates an existing and eligible team as a security manager for an organization, allowing its members to manage security alerts, code security configurations, and dependency reviews for the organization's repositories.

Grants a specified repository access to an authenticated user's existing codespaces secret, enabling codespaces created for that repository to use the secret.

Adds one or more email addresses (which will be initially unverified) to the authenticated user's github account; use this to associate new emails, noting an email verified for another account will error, while an existing email for the current user is accepted.

Adds labels (provided in the request body) to a repository issue; labels that do not already exist are created.

Adds new custom labels to an existing self-hosted runner for an organization; existing labels are not removed, and duplicates are not added.

Adds a github user to a team or updates their role (member or maintainer), inviting them to the organization if not already a member; idempotent, returning current details if no change is made.

Idempotently adds a user to a github team or updates their role using a legacy endpoint; `team id` and `username` must already exist.

Grants or updates a team's permissions ('read', 'write', or 'admin') for a specific project, which must exist within the specified organization and be linked to it.

Sets or modifies a team's permissions for a specific project using a deprecated legacy github api endpoint; ensure the team can access the project's organization, and note that requests with an empty body (e.g., when relying on the default permission) might need a `content-length: 0` header.

Sets or updates a team's permission level for a repository within an organization; the team must be a member of the organization.

Adds or updates a team's repository permissions using the deprecated github legacy teams api; use with caution as this endpoint is deprecated.

Adds a specified github user as a collaborator to an existing organization project with a given permission level.

Adds a repository to an existing organization-level github actions secret that is configured for 'selected' repository access.

Grants an existing repository access to an existing organization-level dependabot secret; the repository must belong to the organization, and the call succeeds without change if access already exists.

Adds and appends custom labels to a self-hosted repository runner, which must be registered and active.

Adds a repository to an organization secret's access list when the secret's visibility is 'selected'; this operation is idempotent.

Grants a repository access to an organization-level github actions variable, if that variable's visibility is set to 'selected repositories'.

Adds one or more social media links (which must be valid, full urls for platforms supported by github) to the authenticated user's public github profile.

Adds status check contexts (provided in the request body, e.g., `{"contexts": ["new-context"]}`) to a protected branch, requiring these contexts to have been previously reported.

Adds specified teams to an organization's active github copilot subscription; teams must exist within the organization.

Overwrites the list of teams (and their child teams) granted push access to a protected branch; the list of team slugs must be provided in the http post request body.

Invites or adds a user to a specific team using a deprecated github api endpoint; prefer 'add or update team membership for a user' instead.

Sets or replaces the list of organization members granted codespaces access billed to the organization; ensure the organization's billing settings allow access for selected members.

Adds specified organization members to an active github copilot subscription, which must have available seats.

Sets/replaces list of users allowed to push to a protected branch; usernames (e.g., `["user1"]`) must be a json array in request body (not schema parameters), an empty array `[]` removes all restrictions.

Approves a workflow run from a forked repository's pull request; call this when such a run requires manual approval due to workflow configuration.

Assigns an existing organization-level role (identified by `role id`) to a team (identified by `team slug`) within a github organization (`org`), provided the organization, team, and role already exist.

Assigns a specific organization role to a user who is a member or an outside collaborator in a github organization, using a valid role id.

Lists docker packages for the authenticated user that encountered conflicts during the docker migration process.

Blocks an existing individual github user (not an organization or your own account), preventing them from interacting with your account and repositories.

Blocks an existing github user from an existing organization, preventing their contributions, collaboration, and forking of the organization's repositories.

Cancels an ongoing repository import if one is actively in progress for the specified repository; note that this github feature is deprecated and may no longer function.

Cancels an existing, pending invitation to join a specified organization using the invitation's unique id.

Cancels an existing, ongoing or queued github pages deployment for a repository using its `pages deployment id`.

Cancels a workflow run in a github repository if it is in a cancellable state (e.g., 'in progress' or 'queued').

Checks if automated security fixes are enabled for a repository; returns 204 (empty response) if enabled, 404 if not or repo not found.

Checks if a github app or oauth access token is valid for the specified client id and retrieves its details, typically to verify its active status and grants.

Checks if a gist, identified by `gist id`, is starred by the authenticated user, returning an empty response (204) if starred, or a 404 error if not starred or not found.

Verifies if a github user can be assigned to issues in a repository; assignability is confirmed by an http 204 (no content) response, resulting in an empty 'data' field in the response.

Checks if a specified github user can be assigned to a given issue within a repository.

Checks if a github user `username` follows `target user`; returns a 204 http status if true, 404 if not or if users are invalid.

Checks if a user is a collaborator on a specified github repository, returning a 204 status if they are, or a 404 status if they are not or if the repository/user does not exist.

Checks if a github user is blocked by an organization; a successful response (204 no content) indicates the user is blocked, while a 404 not found error indicates the user is not blocked.

Checks if a specified github pull request has been merged, indicated by a 204 http status (merged) or 404 (not merged/found).

Use to determine if the authenticated user has starred a specific github repository, which is confirmed by an http 204 status (resulting in an empty dictionary in the response data); the action fails (e.g., http 404) if the repository is not starred or does not exist.

Checks if an existing github user is a member (public or private) of an existing github organization.

Checks if the authenticated github user follows a target github user; an http 204 status indicates the user is followed, while an http 404 status indicates the user is not followed or the target user does not exist.

Checks if private vulnerability reporting is enabled for the specified repository.

Checks if a user is a public member of a github organization; returns an empty response (http 204) if the user is a public member, or an error (e.g., http 404) if the user is not a public member or if the organization/user doesn't exist.

Checks if a team has 'read', 'write', or 'admin' permissions for an organization's specific classic project, returning the project's details if access is confirmed.

Checks a team's permissions (e.g., read, write, admin) for a specific project, given the team and project ids, using a legacy github teams api; returns project details with permissions or a 404 error if the project is not found or not managed by the team.

Checks a team's permissions for a specific repository within an organization, including permissions inherited from parent teams.

Verifies a team's access to a repository using a deprecated github legacy endpoint, returning repository details with permissions upon success or a 204/404 status otherwise.

Checks if the specified github user is blocked by the authenticated user; a 204 no content response indicates the user is blocked, while a 404 not found indicates they are not.

Checks if vulnerability alerts are enabled for a repository; a 204 no content response indicates enabled, while 404 not found suggests they are disabled or the repository is not found.

Deletes github actions caches from a repository matching a specific `key` and an optional git `ref`, used to manage storage or clear outdated/corrupted caches; the action succeeds even if no matching caches are found to delete.

Removes all custom labels from a self-hosted runner for an organization; default labels (e.g., 'self-hosted', 'linux', 'x64') will remain.

Compares two commit points (commits, branches, tags, or shas) within a repository or across forks, using `base...head` or `owner:ref...owner:ref` format for the `basehead` parameter.

Generates a jit configuration for a github organization's new self-hosted runner to run a single job then unregister; the runner group id must exist.

Sets or updates the oidc subject claim customization template for an existing github organization by specifying which claims (e.g., 'repo', 'actor') form the oidc token's subject (`sub`).

Converts an existing organization member, who is not an owner, to an outside collaborator, restricting their access to explicitly granted repositories.

Creates a repository autolink to automatically convert text references (e.g., 'ticket-123') into hyperlinks, using a unique `key prefix` and a `url template` that includes `<num>`.

Creates an encrypted environment variable for a pre-existing environment within a github repository; will fail if the variable name already exists.

Creates a new issue in a github repository, requiring the repository to exist and have issues enabled; specific fields like assignees, milestone, or labels may require push access.

Creates a new comment on an existing github issue or pull request within the specified repository.

Use this action to invite a user to a github organization by their github user id or email, specifying their role and optionally adding them to teams; the 'reinstate' role is for former organization members.

Creates a new classic project board within a specified github organization.

Creates a new repository within a specified github organization, with options for detailed configuration including visibility, features, merge strategies, initial commit, and templates.

Creates a repository ruleset to define and enforce policies (e.g., branch protections, commit formats) for repositories within an existing github organization.

Creates a new, uniquely named github actions variable for an organization, with configurable repository access visibility (all, private, or selected).

Creates a webhook for a github organization to deliver event notifications to a configured url.

Creates a git blob in a repository, requiring content and encoding ('utf-8' or 'base64').

Creates a new check run for a specific commit in a repository, used by external services to report status, detailed feedback, annotations, and images directly within the github ui.

Creates a new check suite for a specific commit (`head sha`) in an original repository (not a fork); github dispatches a `check suite` webhook event with the `requested` action upon success.

Creates a github codespace for the authenticated user, requiring a json request body with either `repository id` (integer) or a `pull request` object (containing `pull request number` (integer) and `repository id` (integer)).

Creates a github codespace for an open pull request in a codespaces-enabled repository, with options to customize its configuration.

Creates a github codespace for the authenticated user in a specified repository, which must be accessible and use a valid `devcontainer.json` if `devcontainer path` is specified.

Creates a new commit in a github repository; the `tree` sha and any `parents` shas must already exist in the repository.

Creates a comment on a specific commit, or on a specific line if `path` and `position` are provided.

Sets a commit's status (e.g., error, failure, pending, success from ci/cd) for a given sha; max 1000 statuses per sha/context.

Creates a custom role with defined permissions within a github organization.

Creates a github deployment for an existing repository, targeting a specific ref (branch, tag, or sha) that must also exist within the repository.

Creates a deployment branch or tag policy for an existing environment in a github repository, using a ruby file.fnmatch pattern (where `*` doesn't match `/`) to specify which branches or tags are deployable.

Creates a status for an existing deployment, updating its operational state, associated urls, and description.

Creates a deploy key for a repository; the repository must exist and be accessible, and the provided key must be a valid public ssh key.

Creates a new discussion post on a specific team's page within an organization.

Creates a new comment on an existing team discussion within a github organization.

Posts a new comment to a specific team discussion using a legacy github api endpoint; note that this endpoint is deprecated and scheduled for removal.

Creates a team discussion (title, body, private) for an existing team `team id` using a deprecated github legacy endpoint; consider newer apis for stability.

Creates a fork of an accessible repository, optionally into a specific organization, with a new name, or copying only the default branch.

Creates a new gist on github with provided files, an optional description, and public/secret visibility.

Creates a new comment on a specified github gist.

Use this action to finalize a github app's creation by exchanging the temporary `code` (received as a url parameter during the app manifest setup redirection) for the app's full configuration details.

Creates a github pages deployment for a repository using a specified artifact and oidc token, provided github pages is enabled and the artifact (containing static assets) is accessible.

Configures or updates github pages for a repository, setting build type and source; ensure a pages workflow exists for 'workflow' `build type`, or `source branch` exists for 'legacy' or unspecified `build type`.

Adds a gpg key to the authenticated user's github account for signing commits and tags.

Creates a new label in a specified github repository, provided the repository exists and the user has write permissions.

Creates a milestone in a github repository for tracking progress on issues or pull requests; requires repository existence and user write permissions.

Creates a project card in a github project column; the request body must contain either a `note` for a note-only card, or both `content id` (id of an issue or pull request) and `content type` (e.g., 'issue', 'pullrequest').

Creates a new column in a github project (classic).

Adds a new, unencrypted public ssh key to the authenticated user's github account; the key must not already be registered to any github account.

Creates a pull request in a github repository, requiring existing `base` and `head` branches; `title` or `issue` must be provided.

Creates a git reference (e.g., a branch or tag) in a repository; the repository must not be empty prior to this operation.

Generates a temporary (one-hour) registration token to add a new self-hosted runner to an organization for github actions.

Generates a time-limited token required to register a new self-hosted runner with a specific repository.

Creates a release in a github repository for a specified tag; the tag must be unique for published releases, and if a `discussion category name` is given, it must already exist.

Generates a token, valid for one hour, to authenticate removing a self-hosted runner from an organization.

Generates a temporary (one-hour validity) token required to unregister and remove a self-hosted runner from a repository.

Posts a reply to a specific review comment on a github pull request, requiring the repository, pull request, and original comment to exist, and a non-empty reply body.

Triggers a github actions workflow or a webhook on a repository by creating a repository dispatch event, allowing programmatic triggering of workflows based on events outside of github.

Creates a new repository for the authenticated user, optionally within an organization if `team id` is specified.

Publishes the specified codespace to a new repository, using the codespace's current state as the initial commit.

Creates a new classic project board within a specified repository; classic projects must be enabled for the target repository.

Creates a uniquely named ruleset for a repository, defining rules for branches or tags with specified enforcement, conditions, and bypass actors.