Hῆphaistos

Hῆphaistos · GPT-Aktionen

Stack Exchange API for Custom GPT Integration

This API schema enables extensive interaction with the Stack Exchange network, including querying questions, answers, users, and tags.

  • GET /questionsRetrieve a list of questions
  • GET /answersRetrieve answers for questions
  • GET /users/{userid}Retrieve information about a specific user
  • GET /users/{userid}/questionsRetrieve questions asked by a specific user
  • GET /users/{userid}/answersRetrieve answers posted by a specific user
  • GET /tagsRetrieve a list of tags
Ursprüngliches API-Schema
{
  "openapi": "3.1.0",
  "info": {
    "title": "Stack Exchange API for Custom GPT Integration",
    "version": "1.0.0",
    "description": "This API schema enables extensive interaction with the Stack Exchange network,  including querying questions, answers, users, and tags.\n"
  },
  "servers": [
    {
      "url": "https://api.stackexchange.com/2.3"
    }
  ],
  "paths": {
    "/questions": {
      "get": {
        "summary": "Retrieve a list of questions",
        "operationId": "getQuestions",
        "parameters": [
          {
            "name": "order",
            "in": "query",
            "required": false,
            "description": "Order of returned items (asc or desc)",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "sort",
            "in": "query",
            "required": false,
            "description": "Sorting criterion (activity, votes, creation, hot)",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "tagged",
            "in": "query",
            "required": false,
            "description": "Filter questions by tags",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "site",
            "in": "query",
            "required": true,
            "description": "Stack Exchange site to query",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of questions",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Question"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/answers": {
      "get": {
        "summary": "Retrieve answers for questions",
        "operationId": "getAnswers",
        "parameters": [
          {
            "name": "order",
            "in": "query",
            "required": false,
            "description": "Order of returned items (asc or desc)",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "sort",
            "in": "query",
            "required": false,
            "description": "Sorting criterion (activity, votes, creation)",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "site",
            "in": "query",
            "required": true,
            "description": "Stack Exchange site to query",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of answers",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Answer"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/users/{userid}": {
      "get": {
        "summary": "Retrieve information about a specific user",
        "operationId": "getUserById",
        "parameters": [
          {
            "name": "userid",
            "in": "path",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "The user's ID on Stack Exchange"
          },
          {
            "name": "site",
            "in": "query",
            "required": true,
            "description": "Stack Exchange site to query",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with user profile information",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            }
          }
        }
      }
    },
    "/users/{userid}/questions": {
      "get": {
        "summary": "Retrieve questions asked by a specific user",
        "operationId": "getQuestionsByUser",
        "parameters": [
          {
            "name": "userid",
            "in": "path",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "The user's ID on Stack Exchange"
          },
          {
            "name": "site",
            "in": "query",
            "required": true,
            "description": "Stack Exchange site to query",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of questions asked by the user",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Question"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/users/{userid}/answers": {
      "get": {
        "summary": "Retrieve answers posted by a specific user",
        "operationId": "getAnswersByUser",
        "parameters": [
          {
            "name": "userid",
            "in": "path",
            "required": true,
            "schema": {
              "type": "integer"
            },
            "description": "The user's ID on Stack Exchange"
          },
          {
            "name": "site",
            "in": "query",
            "required": true,
            "description": "Stack Exchange site to query",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of answers posted by the user",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Answer"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/tags": {
      "get": {
        "summary": "Retrieve a list of tags",
        "operationId": "getTags",
        "parameters": [
          {
            "name": "site",
            "in": "query",
            "required": true,
            "description": "Stack Exchange site to query",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response with a list of tags",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Tag"
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Question": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "Unique identifier for the question"
          },
          "title": {
            "type": "string",
            "description": "Title of the question"
          },
          "body": {
            "type": "string",
            "description": "Body of the question, may include Markdown with embedded images"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Tags associated with the question"
          },
          "creation_date": {
            "type": "integer",
            "description": "Unix timestamp of when the question was created"
          },
          "last_activity_date": {
            "type": "integer",
            "description": "Unix timestamp of the question's last activity"
          },
          "score": {
            "type": "integer",
            "description": "Score of the question"
          },
          "answer_count": {
            "type": "integer",
            "description": "Number of answers the question has received"
          },
          "owner": {
            "$ref": "#/components/schemas/User"
          },
          "is_answered": {
            "type": "boolean",
            "description": "Indicates whether the question has an accepted answer"
          }
        }
      },
      "Answer": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "Unique identifier for the answer"
          },
          "question_id": {
            "type": "integer",
            "description": "Identifier of the associated question"
          },
          "body": {
            "type": "string",
            "description": "Body of the answer, may include Markdown with embedded images"
          },
          "creation_date": {
            "type": "integer",
            "description": "Unix timestamp of when the answer was created"
          },
          "last_activity_date": {
            "type": "integer",
            "description": "Unix timestamp of the answer's last activity"
          },
          "score": {
            "type": "integer",
            "description": "Score of the answer"
          },
          "owner": {
            "$ref": "#/components/schemas/User"
          }
        }
      },
      "User": {
        "type": "object",
        "properties": {
          "user_id": {
            "type": "integer",
            "description": "Unique identifier for the user"
          },
          "display_name": {
            "type": "string",
            "description": "Display name of the user"
          },
          "profile_image": {
            "type": "string",
            "format": "uri",
            "description": "URL to the user's profile image"
          },
          "reputation": {
            "type": "integer",
            "description": "User's reputation score"
          },
          "accept_rate": {
            "type": "integer",
            "description": "Percentage of the user's questions that have accepted answers"
          }
        }
      },
      "Tag": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "description": "Name of the tag"
          },
          "count": {
            "type": "integer",
            "description": "Number of questions associated with this tag"
          },
          "has_synonyms": {
            "type": "boolean",
            "description": "Indicates if the tag has synonyms"
          }
        }
      }
    }
  }
}

GitHub API for Custom GPT with Image Support

This API facilitates advanced interactions with GitHub, including enhanced support for image content associated with user profiles, repositories, issues, and pull requests.

  • GET /users/{username}Get user profile information, including avatar image URL.
  • GET /users/{username}/reposList repositories for a user.
  • GET /repos/{owner}/{repo}/issuesList all issues for a repository, including any image URLs in issue bodies.
  • POST /repos/{owner}/{repo}/issuesCreate an issue, potentially including image URLs in the body.
  • GET /repos/{owner}/{repo}/pullsList all pull requests for a repository, including any image URLs in pull request bodies.
  • GET /repos/{owner}/{repo}/commitsList recent commits in a repository.
Ursprüngliches API-Schema
{
  "openapi": "3.1.0",
  "info": {
    "title": "GitHub API for Custom GPT with Image Support",
    "version": "1.0",
    "description": "This API facilitates advanced interactions with GitHub, including enhanced support for image content associated with user profiles, repositories, issues, and pull requests."
  },
  "servers": [
    {
      "url": "https://api.github.com"
    }
  ],
  "components": {
    "securitySchemes": {
      "BearerAuth": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "description": "Bearer token for authorized access to GitHub API."
      }
    },
    "schemas": {
      "UserProfile": {
        "type": "object",
        "properties": {
          "login": {
            "type": "string",
            "description": "Username of the user."
          },
          "id": {
            "type": "integer",
            "description": "User ID."
          },
          "avatar_url": {
            "type": "string",
            "format": "uri",
            "description": "URL of the user's avatar image."
          },
          "html_url": {
            "type": "string",
            "format": "uri",
            "description": "URL of the user's GitHub profile."
          },
          "followers_count": {
            "type": "integer",
            "description": "Total number of followers."
          },
          "following_count": {
            "type": "integer",
            "description": "Total number of users the user is following."
          },
          "public_repos": {
            "type": "integer",
            "description": "Total number of public repositories."
          }
        }
      },
      "Repository": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "Repository ID."
          },
          "name": {
            "type": "string",
            "description": "Name of the repository."
          },
          "full_name": {
            "type": "string",
            "description": "Full name of the repository, including owner."
          },
          "private": {
            "type": "boolean",
            "description": "Indicates if the repository is private."
          },
          "html_url": {
            "type": "string",
            "format": "uri",
            "description": "URL of the repository."
          },
          "description": {
            "type": "string",
            "description": "Repository description."
          },
          "stargazers_count": {
            "type": "integer",
            "description": "Total number of stars."
          },
          "watchers_count": {
            "type": "integer",
            "description": "Total number of watchers."
          },
          "language": {
            "type": "string",
            "description": "Primary language of the repository."
          },
          "forks_count": {
            "type": "integer",
            "description": "Total number of forks."
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "Timestamp of repository creation."
          }
        }
      },
      "Issue": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "Unique identifier for the issue."
          },
          "title": {
            "type": "string",
            "description": "Title of the issue."
          },
          "body": {
            "type": "string",
            "description": "Detailed description of the issue, may include Markdown with embedded images."
          },
          "state": {
            "type": "string",
            "description": "State of the issue (open, closed)."
          }
        }
      },
      "Commit": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "Unique identifier for the commit."
          },
          "message": {
            "type": "string",
            "description": "Commit message."
          },
          "author": {
            "$ref": "#/components/schemas/UserProfile"
          },
          "url": {
            "type": "string",
            "format": "uri",
            "description": "URL of the commit."
          }
        }
      },
      "PullRequest": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "Unique identifier for the pull request."
          },
          "title": {
            "type": "string",
            "description": "Title of the pull request."
          },
          "body": {
            "type": "string",
            "description": "Detailed description of the pull request, may include Markdown with embedded images."
          },
          "state": {
            "type": "string",
            "description": "State of the pull request (open, closed)."
          }
        }
      }
    }
  },
  "security": [
    {
      "BearerAuth": []
    }
  ],
  "paths": {
    "/users/{username}": {
      "get": {
        "summary": "Get user profile information, including avatar image URL.",
        "operationId": "getUserProfile",
        "parameters": [
          {
            "name": "username",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "GitHub username"
          }
        ],
        "responses": {
          "200": {
            "description": "Profile information of the user, including avatar image URL.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UserProfile"
                }
              }
            }
          }
        }
      }
    },
    "/users/{username}/repos": {
      "get": {
        "summary": "List repositories for a user.",
        "operationId": "listUserRepos",
        "parameters": [
          {
            "name": "username",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "GitHub username"
          }
        ],
        "responses": {
          "200": {
            "description": "List of repositories for the user.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Repository"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/repos/{owner}/{repo}/issues": {
      "get": {
        "summary": "List all issues for a repository, including any image URLs in issue bodies.",
        "operationId": "listRepoIssues",
        "parameters": [
          {
            "name": "owner",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The username of the owner of the repository."
          },
          {
            "name": "repo",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The name of the repository."
          }
        ],
        "responses": {
          "200": {
            "description": "An array of issues.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Issue"
                  }
                }
              }
            }
          }
        }
      },
      "post": {
        "summary": "Create an issue, potentially including image URLs in the body.",
        "operationId": "createRepoIssue",
        "parameters": [
          {
            "name": "owner",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The username of the owner of the repository."
          },
          {
            "name": "repo",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The name of the repository."
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Issue"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Issue created."
          }
        }
      }
    },
    "/repos/{owner}/{repo}/pulls": {
      "get": {
        "summary": "List all pull requests for a repository, including any image URLs in pull request bodies.",
        "operationId": "listRepoPullRequests",
        "parameters": [
          {
            "name": "owner",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The username of the owner of the repository."
          },
          {
            "name": "repo",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The name of the repository."
          }
        ],
        "responses": {
          "200": {
            "description": "An array of pull requests.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/PullRequest"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/repos/{owner}/{repo}/commits": {
      "get": {
        "summary": "List recent commits in a repository.",
        "operationId": "listRepoCommits",
        "parameters": [
          {
            "name": "owner",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The username of the owner of the repository."
          },
          {
            "name": "repo",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "The name of the repository."
          }
        ],
        "responses": {
          "200": {
            "description": "An array of commits.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Commit"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Hacker News API

API for accessing Hacker News data including items, users, and real-time updates.

  • GET /topstories.jsonTop Stories

    Retrieve top stories from Hacker News.

  • GET /newstories.jsonNew Stories

    Retrieve latest stories from Hacker News.

  • GET /beststories.jsonBest Stories

    Retrieve best stories from Hacker News.

  • GET /item/{itemId}.jsonItem Information

    Retrieve information about a specific item by its ID.

  • GET /user/{userId}.jsonUser Information

    Retrieve information about a specific user by their ID.

Ursprüngliches API-Schema
{
  "openapi": "3.0.0",
  "info": {
    "title": "Hacker News API",
    "version": "1.0.0",
    "description": "API for accessing Hacker News data including items, users, and real-time updates."
  },
  "servers": [
    {
      "url": "https://hacker-news.firebaseio.com/v0"
    }
  ],
  "paths": {
    "/topstories.json": {
      "get": {
        "summary": "Top Stories",
        "description": "Retrieve top stories from Hacker News.",
        "operationId": "getTopStories",
        "responses": {
          "200": {
            "description": "An array of item IDs for top stories.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/newstories.json": {
      "get": {
        "summary": "New Stories",
        "description": "Retrieve latest stories from Hacker News.",
        "operationId": "getNewStories",
        "responses": {
          "200": {
            "description": "An array of item IDs for new stories.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/beststories.json": {
      "get": {
        "summary": "Best Stories",
        "description": "Retrieve best stories from Hacker News.",
        "operationId": "getBestStories",
        "responses": {
          "200": {
            "description": "An array of item IDs for best stories.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "integer"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/item/{itemId}.json": {
      "get": {
        "summary": "Item Information",
        "description": "Retrieve information about a specific item by its ID.",
        "operationId": "getItemById",
        "parameters": [
          {
            "name": "itemId",
            "in": "path",
            "required": true,
            "description": "The ID of the item",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Detailed information about the item.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Item"
                }
              }
            }
          }
        },
        "x-examples": {
          "example1": {
            "summary": "Example request for an item",
            "value": {
              "itemId": 8863
            }
          }
        }
      }
    },
    "/user/{userId}.json": {
      "get": {
        "summary": "User Information",
        "description": "Retrieve information about a specific user by their ID.",
        "operationId": "getUserById",
        "parameters": [
          {
            "name": "userId",
            "in": "path",
            "required": true,
            "description": "The ID of the user",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Detailed information about the user.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Item": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "The item's unique ID."
          },
          "deleted": {
            "type": "boolean",
            "description": "True if the item is deleted."
          },
          "type": {
            "type": "string",
            "description": "The type of item (e.g., story, comment)."
          },
          "by": {
            "type": "string",
            "description": "The username of the item's author."
          },
          "time": {
            "type": "integer",
            "description": "Creation time of the item, in Unix Time."
          },
          "text": {
            "type": "string",
            "description": "The text of the item, if available."
          },
          "dead": {
            "type": "boolean",
            "description": "True if the item is marked as dead."
          },
          "parent": {
            "type": "integer",
            "description": "The parent item's ID, for comments or replies."
          },
          "poll": {
            "type": "integer",
            "description": "The poll ID, if the item is a poll."
          },
          "kids": {
            "type": "array",
            "items": {
              "type": "integer"
            },
            "description": "Array of comment IDs, if the item has comments."
          },
          "url": {
            "type": "string",
            "description": "The URL of the story, if applicable."
          },
          "score": {
            "type": "integer",
            "description": "The score of the story or poll."
          },
          "title": {
            "type": "string",
            "description": "The title of the story, poll, or other items."
          },
          "parts": {
            "type": "array",
            "items": {
              "type": "integer"
            },
            "description": "Parts of the poll, if the item is a poll."
          },
          "descendants": {
            "type": "integer",
            "description": "The number of direct and indirect child comments."
          }
        }
      },
      "User": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "The user's unique ID."
          },
          "delay": {
            "type": "integer",
            "description": "Delay in minutes before the user's comments are visible."
          },
          "created": {
            "type": "integer",
            "description": "Account creation time in Unix Time."
          },
          "karma": {
            "type": "integer",
            "description": "The user's karma score."
          },
          "about": {
            "type": "string",
            "description": "Brief profile description of the user."
          },
          "submitted": {
            "type": "array",
            "items": {
              "type": "integer"
            },
            "description": "List of IDs for submissions made by the user."
          }
        }
      }
    }
  }
}

DEV.to API

API for accessing DEV.to platform data including articles, comments, and user profiles.

  • GET /articlesRetrieve Articles

    Get a list of the latest articles.

  • GET /articles/{id}Article by ID

    Retrieve a specific article by its ID.

  • GET /comments/{id}Comments by Article ID

    Retrieve comments for a specific article by the article's ID.

  • GET /users/{id}User Profile

    Retrieve a specific user's profile by their ID.

Ursprüngliches API-Schema
{
  "openapi": "3.0.0",
  "info": {
    "title": "DEV.to API",
    "version": "1.0.0",
    "description": "API for accessing DEV.to platform data including articles, comments, and user profiles."
  },
  "servers": [
    {
      "url": "https://dev.to/api"
    }
  ],
  "paths": {
    "/articles": {
      "get": {
        "summary": "Retrieve Articles",
        "description": "Get a list of the latest articles.",
        "operationId": "getArticles",
        "responses": {
          "200": {
            "description": "An array of articles.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Article"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/articles/{id}": {
      "get": {
        "summary": "Article by ID",
        "description": "Retrieve a specific article by its ID.",
        "operationId": "getArticleById",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "description": "The ID of the article",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Detailed information about the article.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Article"
                }
              }
            }
          }
        }
      }
    },
    "/comments/{id}": {
      "get": {
        "summary": "Comments by Article ID",
        "description": "Retrieve comments for a specific article by the article's ID.",
        "operationId": "getCommentsByArticleId",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "description": "The ID of the article",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "An array of comments for the article.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Comment"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/users/{id}": {
      "get": {
        "summary": "User Profile",
        "description": "Retrieve a specific user's profile by their ID.",
        "operationId": "getUserById",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "description": "The ID of the user",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Detailed information about the user's profile.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Article": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "The unique ID of the article."
          },
          "title": {
            "type": "string",
            "description": "The title of the article."
          },
          "description": {
            "type": "string",
            "description": "A short description of the article."
          },
          "body_html": {
            "type": "string",
            "description": "The HTML content of the article."
          },
          "tag_list": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "List of tags associated with the article."
          },
          "user": {
            "$ref": "#/components/schemas/User"
          },
          "comments_count": {
            "type": "integer",
            "description": "The count of comments on the article."
          },
          "public_reactions_count": {
            "type": "integer",
            "description": "The count of public reactions for the article."
          },
          "cover_image": {
            "type": "string",
            "format": "uri",
            "description": "URL of the cover image for the article."
          },
          "published_at": {
            "type": "string",
            "format": "date-time",
            "description": "The published date and time of the article."
          }
        }
      },
      "Comment": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "The unique ID of the comment."
          },
          "body_html": {
            "type": "string",
            "description": "The HTML content of the comment."
          },
          "user": {
            "$ref": "#/components/schemas/User"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "The creation date and time of the comment."
          }
        }
      },
      "User": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer",
            "description": "The unique ID of the user."
          },
          "username": {
            "type": "string",
            "description": "The username of the user."
          },
          "name": {
            "type": "string",
            "description": "The name of the user."
          },
          "twitter_username": {
            "type": "string",
            "description": "The user's Twitter username."
          },
          "github_username": {
            "type": "string",
            "description": "The user's GitHub username."
          },
          "website_url": {
            "type": "string",
            "format": "uri",
            "description": "The website URL of the user."
          },
          "profile_image": {
            "type": "string",
            "format": "uri",
            "description": "URL of the user's profile image."
          },
          "articles_count": {
            "type": "integer",
            "description": "The number of articles published by the user."
          },
          "location": {
            "type": "string",
            "description": "The location of the user."
          },
          "joined_at": {
            "type": "string",
            "format": "date-time",
            "description": "The date and time when the user joined."
          },
          "bio": {
            "type": "string",
            "description": "The bio of the user."
          },
          "followers_count": {
            "type": "integer",
            "description": "The number of followers the user has."
          },
          "following_count": {
            "type": "integer",
            "description": "The number of users the user is following."
          }
        }
      }
    }
  }
}

Custom Pinterest-Like API

An API facilitating interaction with a platform similar to Pinterest, including user management, board creation, pinning, and image handling.

  • POST /usersCreate a new user.
  • GET /users/{userId}Get details of a specific user.
  • POST /boardsCreate a new board for a user.
  • GET /boards/{boardId}Retrieve details of a specific board.
  • POST /pinsAdd a new pin to a board.
  • POST /images/uploadUpload a new image.
Ursprüngliches API-Schema
{
  "openapi": "3.1.0",
  "info": {
    "title": "Custom Pinterest-Like API",
    "version": "1.0",
    "description": "An API facilitating interaction with a platform similar to Pinterest, including user management, board creation, pinning, and image handling."
  },
  "servers": [
    {
      "url": "https://api.yourdomain.com/v1"
    }
  ],
  "paths": {
    "/users": {
      "post": {
        "summary": "Create a new user.",
        "operationId": "createUser",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NewUser"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "User created successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            }
          }
        }
      }
    },
    "/users/{userId}": {
      "get": {
        "summary": "Get details of a specific user.",
        "operationId": "getUserDetails",
        "parameters": [
          {
            "name": "userId",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "User details retrieved successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/User"
                }
              }
            }
          }
        }
      }
    },
    "/boards": {
      "post": {
        "summary": "Create a new board for a user.",
        "operationId": "createBoard",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NewBoard"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Board created successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Board"
                }
              }
            }
          }
        }
      }
    },
    "/boards/{boardId}": {
      "get": {
        "summary": "Retrieve details of a specific board.",
        "operationId": "getBoardDetails",
        "parameters": [
          {
            "name": "boardId",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Board details retrieved successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Board"
                }
              }
            }
          }
        }
      }
    },
    "/pins": {
      "post": {
        "summary": "Add a new pin to a board.",
        "operationId": "createPin",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NewPin"
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Pin created successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Pin"
                }
              }
            }
          }
        }
      }
    },
    "/images/upload": {
      "post": {
        "summary": "Upload a new image.",
        "operationId": "uploadImage",
        "requestBody": {
          "required": true,
          "content": {
            "multipart/form-data": {
              "schema": {
                "type": "object",
                "properties": {
                  "image": {
                    "type": "string",
                    "format": "binary",
                    "description": "Image file to upload."
                  }
                }
              }
            }
          }
        },
        "responses": {
          "201": {
            "description": "Image uploaded successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "imageUrl": {
                      "type": "string",
                      "format": "uri",
                      "description": "URL of the uploaded image."
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "NewUser": {
        "type": "object",
        "properties": {
          "username": {
            "type": "string"
          },
          "email": {
            "type": "string"
          },
          "password": {
            "type": "string"
          }
        }
      },
      "User": {
        "type": "object",
        "properties": {
          "userId": {
            "type": "string"
          },
          "username": {
            "type": "string"
          },
          "email": {
            "type": "string"
          },
          "profileImage": {
            "type": "string",
            "format": "uri"
          }
        }
      },
      "NewBoard": {
        "type": "object",
        "properties": {
          "userId": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          }
        }
      },
      "Board": {
        "type": "object",
        "properties": {
          "boardId": {
            "type": "string"
          },
          "userId": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "pins": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Pin"
            }
          }
        }
      },
      "NewPin": {
        "type": "object",
        "properties": {
          "boardId": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "imageUrl": {
            "type": "string",
            "format": "uri"
          }
        }
      },
      "Pin": {
        "type": "object",
        "properties": {
          "pinId": {
            "type": "string"
          },
          "boardId": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "imageUrl": {
            "type": "string",
            "format": "uri"
          }
        }
      }
    }
  }
}