🍋 Yuzu
Dashboard

Getting Started

The Yuzu Platform

Guides

Creating API Keys

Rate Limits

Usage with Apollo React/React Native

Recipes

Build a live-updating stock price badge

Show the latest exchange rates for your product

Streaming API

Subscription and Authorization

Available streams

Message reference

GraphQL API

Introduction to GraphQL

Making GraphQL Requests

Authorization

Pagination

Errors

Schema Reference
GraphQL API

Making GraphQL Requests

Even though GraphQL is a great fit for frontend applications using Apollo, GraphQL can easily be used in any environment, with any programming language.

Frontend environments

React/React Native

Apollo is the defacto framework to build using GraphQL on the web, Android, or iOS. If you're building for the web in React, check out our guide on how to get started:

Getting started with Yuzu & React.

Native Mobile

If you're building on Android or iOS, check out Apollo's docs on how to get started on those platforms:

  • Apollo Android
  • Apollo iOS

Backend/headless environments

If you're using GraphQL on the backend or another headless environment, there's no framework required. Making GraphQL requests is as simple as making an HTTP POST request.

Here are a few examples using common languages:

Node.js (Axios) Python (Requests) Ruby (HTTParty) Go 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

const axios = require('axios');

async function graphql(query, variables = null) {
  const options = {
    url: 'https://graph.yuzu.dev/graphql',
    method: "POST",
    headers: {
      'content-type': 'application/json',
      'authorization': `Bearer demo-LNxj43XvPrk`
    },
    data: JSON.stringify({
      query, variables
    })
  };

  return await axios(options);
}

const query = `
query FigiLookup($symbols: [String!]) {
  securities(input: { symbols: $symbols }) {
    symbol
    figiComposite
  }
}
`

graphql(query, { symbols: ['AAPL', 'TSLA'] })
  .then((r) => console.log(r.data))
Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import requests
import json

url = 'https://graph.yuzu.dev/graphql'
headers = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer demo-LNxj43XvPrk'
        }

def graphql(query, variables = {}):
    data = json.dumps({
        'query': query,
        'variables': variables
        })
    return requests.post(url, headers=headers, data=data)

query = """
  query FigiLookup($symbols: [String!]) {
    securities(input: { symbols: $symbols }) {
      symbol
      figiComposite
    }
  }
"""

response = send_graphql(query, variables={ 'symbols': ['AAPL', 'TSLA'] })

print(response.json())
Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

require 'http'
require 'json'

BASE_URL = 'https://graph.yuzu.dev/graphql'
CLIENT = HTTP::Client.new(
  headers: {
    'Content-Type': 'application/json',
    'Authorization' => 'Bearer demo-LNxj43XvPrk'
  }
)

def graphql(query, variables: {})
  CLIENT.post(BASE_URL,
              body: JSON.generate({ query: query, variables: variables }))
end

graphql_query = "query { usMarketHours { openNow } }"

response = graphql(graphql_query)

puts response
Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

package main

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

const (
  BASE_URL = "https://graph.yuzu.dev/graphql"
  TOKEN = "demo-LNxj43XvPrk"
)

type GraphQLRequest struct {
  Query     string         `json:"query"`
  Variables map[string]any `json:"variables"`
}

type GraphQLResponse[T any] struct {
  Data T `json:"data"`
  Errors map[string]any `json:"errors"`
}

func GraphQL[T any](request GraphQLRequest) (GraphQLResponse[T], error) {
  var body bytes.Buffer
  encoder := json.NewEncoder(&body)
  if err := encoder.Encode(request); err != nil {
    return GraphQLResponse[T]{}, fmt.Errorf("error encoding graphql request: %s", err)
  }

  req, err := http.NewRequest("POST", BASE_URL, &body)
  if err != nil {
    return GraphQLResponse[T]{}, fmt.Errorf("error creating http request: %s", err)
  }

  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", TOKEN))

  response, err := http.DefaultClient.Do(req)
  if err != nil {
    return GraphQLResponse[T]{}, fmt.Errorf("error making HTTP Request: %s", err)
  }
  defer response.Body.Close()

  decoder := json.NewDecoder(response.Body)
  var parsedResponse GraphQLResponse[T]
  decoder.Decode(&parsedResponse)

  return parsedResponse, nil
}

func main() {
  query := `
  query FigiLookup($symbols: [String!]) {
    securities(input: { symbols: $symbols }) {
      symbol
      figiComposite
    }
  }
  `

  request := GraphQLRequest{
    Query: query,
    Variables: map[string]any{
      "symbols": []string{"AAPL", "TSLA"},
    },
  }

  type response struct {
    Securities []struct {
      Symbol        string `json:"symbol"`
      FigiComposite string `json:"figiComposite"`
    } `json:"securities"`
  }

  responseBody, err := GraphQL[response](request)
  if err != nil {
    panic(err)
  }

  fmt.Printf("%+v\n", responseBody.Data)
}
Copy

Introduction to GraphQL

Authorization