DEVELOPER TOOLS

Search GitHub Discussions API

Search GitHub Discussions across all repositories (GraphQL). Returns title, body, author, repository, category, comment count and the node id you need to reply, with cursor pagination. Requires your own GitHub token - GitHub's GraphQL API does not serve anonymous callers.

githubsearchdiscussionsgraphqldeveloperpython

Try it free Get an API key

How to call it

Send one POST to api.upapi.io/github-search-discussions.get with your key in the X-Api-Key header and the parameters below as a JSON body. Each call spends 1 weighted unit of your monthly quota. The operation times out after 30 seconds. Identical requests are served from cache for 120 seconds, unbilled.

endpoint

POST https://api.upapi.io/github-search-discussions.get

Search GitHub Discussions API reference

Request parameters

q: stringrequired — GitHub search syntax for discussions, e.g. '"note taking" is:open'
after: string — pageInfo.endCursor from the previous page
first: integer — Rows to return (max 100)
token: stringrequired — GitHub token - GraphQL does not accept anonymous calls
proxyUrl: string — Optional exit to send from (direct otherwise)

Response fields

items: arrayrequired
items[].id: stringrequired — GraphQL node id (the value addDiscussionComment takes)
items[].url: stringrequired
items[].body: stringrequired
items[].title: stringrequired
items[].author: stringrequired
items[].number: integerrequired
items[].category: stringrequired
items[].comments: integerrequired
items[].createdAt: stringrequired
items[].repository: stringrequired
endCursor: stringrequired
fetchedAt: stringrequired
rateLimit: objectrequired — The rate-limit headers GitHub returned on THIS response, surfaced so the caller can pace itself instead of the operation sleeping on its behalf.
rateLimit.limit: integerrequired — X-RateLimit-Limit: requests allowed per window
rateLimit.resetAt: stringrequired — X-RateLimit-Reset as an ISO-8601 UTC timestamp
rateLimit.resource: stringrequired — X-RateLimit-Resource: which bucket (core, search, graphql, ...)
rateLimit.remaining: integerrequired — X-RateLimit-Remaining: requests left
rateLimit.resetEpoch: integerrequired — X-RateLimit-Reset as unix seconds
totalCount: integerrequired
hasNextPage: booleanrequired

Example request and response

The example response is generated from this operation’s published output schema — it shows the shape and field names, not values from a recorded call.

json — example request body

{
  "q": "\"note taking\" is:open",
  "first": 30,
  "token": "example"
}

json — example response shape

{
  "items": [
    {
      "id": "example",
      "url": "https://github.com",
      "body": "example",
      "title": "Alan Turing",
      "author": "example",
      "number": 1,
      "category": "example",
      "comments": 1,
      "createdAt": "example",
      "repository": "example"
    }
  ],
  "endCursor": "example",
  "fetchedAt": "example",
  "rateLimit": {
    "limit": 5,
    "resetAt": "example",
    "resource": "example",
    "remaining": 1,
    "resetEpoch": 1
  },
  "totalCount": 1,
  "hasNextPage": false
}

Code snippets

cURL

curl

curl -X POST https://api.upapi.io/github-search-discussions.get \
  -H 'Content-Type: application/json' \
  -H 'x-api-key: YOUR_API_KEY' \
  -d '{ "q": "\"note taking\" is:open", "first": 30, "token": "example" }'

JavaScript

javascript

const response = await fetch('https://api.upapi.io/github-search-discussions.get', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': 'YOUR_API_KEY',
  },
  body: JSON.stringify({
  "q": "\"note taking\" is:open",
  "first": 30,
  "token": "example"
}),
});

const data = await response.json();
console.log(data);

Python

python

import requests

response = requests.post(
    'https://api.upapi.io/github-search-discussions.get',
    headers={
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY',
    },
    json={
  "q": "\"note taking\" is:open",
  "first": 30,
  "token": "example"
},
)

print(response.json())

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	payload := []byte(`{ "q": "\"note taking\" is:open", "first": 30, "token": "example" }`)

	req, _ := http.NewRequest("POST", "https://api.upapi.io/github-search-discussions.get", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-api-key", "YOUR_API_KEY")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	var result map[string]any
	json.Unmarshal(body, &result)
	fmt.Println(result)
}

PHP

php

<?php

$payload = json_encode([
    'q' => '"note taking" is:open',
    'first' => 30,
    'token' => 'example',
]);

$ch = curl_init('https://api.upapi.io/github-search-discussions.get');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $payload,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Content-Type: application/json',
        'x-api-key: YOUR_API_KEY',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
var_dump($data);

Ruby

ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.upapi.io/github-search-discussions.get')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == 'https'

request = Net::HTTP::Post.new(uri.path)
request['Content-Type'] = 'application/json'
request['x-api-key'] = 'YOUR_API_KEY'
request.body = { "q": "\"note taking\" is:open", "first": 30, "token": "example" }.to_json

response = http.request(request)
puts JSON.parse(response.body)

Java

java

import okhttp3.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;

OkHttpClient client = new OkHttpClient();
ObjectMapper mapper = new ObjectMapper();

String json = "{ \"q\": \"\\\"note taking\\\" is:open\", \"first\": 30, \"token\": \"example\" }";

RequestBody body = RequestBody.create(json, MediaType.get("application/json"));
Request request = new Request.Builder()
    .url("https://api.upapi.io/github-search-discussions.get")
    .post(body)
    .addHeader("Content-Type", "application/json")
    .addHeader("x-api-key", "YOUR_API_KEY")
    .build();

try (Response response = client.newCall(request).execute()) {
    Map<?, ?> result = mapper.readValue(response.body().string(), Map.class);
    System.out.println(result);
}

csharp

using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var payload = JsonSerializer.Deserialize<object>("{ \"q\": \"\\\"note taking\\\" is:open\", \"first\": 30, \"token\": \"example\" }");
var response = await client.PostAsJsonAsync("https://api.upapi.io/github-search-discussions.get", payload);

var result = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(result);

Frequently asked questions

How much does the Search GitHub Discussions API cost per call?

Each call spends 1 weighted unit of your plan's monthly quota. Full pricing is at https://upapi.io/pricing.

How do I authenticate to the Search GitHub Discussions API?

Send your key in the X-Api-Key header. A free guest key is available without creating an account.

Are Search GitHub Discussions API responses cached?

Yes — identical requests are served from cache for 120 seconds, and a cache hit is not billed.

More Developer Tools APIs

Search GitHub Issues Search GitHub Repositories Search GitHub Users Get GitHub User Commit Emails List GitHub Issue Comments List GitHub Repository Contributors List GitHub Repository Issues Get GitHub Repository

Browse every Developer Tools API →