id,page,ref,title,content,breadcrumbs,references
settings:setting-cache-size-kb,settings,setting-cache-size-kb,cache_size_kb,"Sets the amount of memory SQLite uses for its  per-connection cache , in KB. 
                 datasette mydatabase.db --setting cache_size_kb 5000","[""Settings"", ""Settings""]","[{""href"": ""https://www.sqlite.org/pragma.html#pragma_cache_size"", ""label"": ""per-connection cache""}]"
settings:setting-base-url,settings,setting-base-url,base_url,"If you are running Datasette behind a proxy, it may be useful to change the root path used for the Datasette instance. 
                 For example, if you are sending traffic from  https://www.example.com/tools/datasette/  through to a proxied Datasette instance you may wish Datasette to use  /tools/datasette/  as its root URL. 
                 You can do that like so: 
                 datasette mydatabase.db --setting base_url /tools/datasette/","[""Settings"", ""Settings""]",[]
settings:setting-allow-signed-tokens,settings,setting-allow-signed-tokens,allow_signed_tokens,"Should users be able to create signed API tokens to access Datasette? 
                 This is turned on by default. Use the following to turn it off: 
                 datasette mydatabase.db --setting allow_signed_tokens off 
                 Turning this setting off will disable the  /-/create-token  page,  described here . It will also cause any incoming  Authorization: Bearer dstok_...  API tokens to be ignored.","[""Settings"", ""Settings""]",[]
settings:setting-allow-facet,settings,setting-allow-facet,allow_facet,"Allow users to specify columns they would like to facet on using the  ?_facet=COLNAME  URL parameter to the table view. 
                 This is enabled by default. If disabled, facets will still be displayed if they have been specifically enabled in  metadata.json  configuration for the table. 
                 Here's how to disable this feature: 
                 datasette mydatabase.db --setting allow_facet off","[""Settings"", ""Settings""]",[]
settings:setting-allow-download,settings,setting-allow-download,allow_download,"Should users be able to download the original SQLite database using a link on the database index page? This is turned on by default. However, databases can only be downloaded if they are served in immutable mode and not in-memory. If downloading is unavailable for either of these reasons, the download link is hidden even if  allow_download  is on. To disable database downloads, use the following: 
                 datasette mydatabase.db --setting allow_download off","[""Settings"", ""Settings""]",[]
settings:setting-allow-csv-stream,settings,setting-allow-csv-stream,allow_csv_stream,"Enables  the CSV export feature  where an entire table
                    (potentially hundreds of thousands of rows) can be exported as a single CSV
                    file. This is turned on by default - you can turn it off like this: 
                 datasette mydatabase.db --setting allow_csv_stream off","[""Settings"", ""Settings""]",[]
settings:setting-publish-secrets,settings,setting-publish-secrets,Using secrets with datasette publish,"The  datasette publish  and  datasette package  commands both generate a secret for you automatically when Datasette is deployed. 
             This means that every time you deploy a new version of a Datasette project, a new secret will be generated. This will cause signed cookies to become invalid on every fresh deploy. 
             You can fix this by creating a secret that will be used for multiple deploys and passing it using the  --secret  option: 
             datasette publish cloudrun mydb.db --service=my-service --secret=cdb19e94283a20f9d42cca5","[""Settings""]",[]
settings:using-setting,settings,using-setting,Using --setting,"Datasette supports a number of settings. These can be set using the  --setting name value  option to  datasette serve . 
             You can set multiple settings at once like this: 
             datasette mydatabase.db \
  --setting default_page_size 50 \
  --setting sql_time_limit_ms 3500 \
  --setting max_returned_rows 2000 
             Settings can also be specified  in the database.yaml configuration file .","[""Settings""]",[]
settings:id1,settings,id1,Settings,,[],[]
settings:id2,settings,id2,Settings,"The following options can be set using  --setting name value , or by storing them in the  settings.json  file for use with  Configuration directory mode .","[""Settings""]",[]
settings:setting-secret,settings,setting-secret,Configuring the secret,"Datasette uses a secret string to sign secure values such as cookies. 
             If you do not provide a secret, Datasette will create one when it starts up. This secret will reset every time the Datasette server restarts though, so things like authentication cookies and  API tokens  will not stay valid between restarts. 
             You can pass a secret to Datasette in two ways: with the  --secret  command-line option or by setting a  DATASETTE_SECRET  environment variable. 
             datasette mydb.db --secret=SECRET_VALUE_HERE 
             Or: 
             export DATASETTE_SECRET=SECRET_VALUE_HERE
datasette mydb.db 
             One way to generate a secure random secret is to use Python like this: 
             python3 -c 'import secrets; print(secrets.token_hex(32))'
cdb19e94283a20f9d42cca50c5a4871c0aa07392db308755d60a1a5b9bb0fa52 
             Plugin authors make use of this signing mechanism in their plugins using  .sign(value, namespace=""default"")  and  .unsign(value, namespace=""default"") .","[""Settings""]",[]
settings:config-dir,settings,config-dir,Configuration directory mode,"Normally you configure Datasette using command-line options. For a Datasette instance with custom templates, custom plugins, a static directory and several databases this can get quite verbose: 
             datasette one.db two.db \
  --metadata=metadata.json \
  --template-dir=templates/ \
  --plugins-dir=plugins \
  --static css:css 
             As an alternative to this, you can run Datasette in  configuration directory  mode. Create a directory with the following structure: 
             # In a directory called my-app:
my-app/one.db
my-app/two.db
my-app/datasette.yaml
my-app/metadata.json
my-app/templates/index.html
my-app/plugins/my_plugin.py
my-app/static/my.css 
             Now start Datasette by providing the path to that directory: 
             datasette my-app/ 
             Datasette will detect the files in that directory and automatically configure itself using them. It will serve all  *.db  files that it finds, will load  metadata.json  if it exists, and will load the  templates ,  plugins  and  static  folders if they are present. 
             The files that can be included in this directory are as follows. All are optional. 
             
                 
                     *.db  (or  *.sqlite3  or  *.sqlite ) - SQLite database files that will be served by Datasette 
                 
                 
                     datasette.yaml  -  Configuration  for the Datasette instance 
                 
                 
                     metadata.json  -  Metadata  for those databases -  metadata.yaml  or  metadata.yml  can be used as well 
                 
                 
                     inspect-data.json  - the result of running  datasette inspect *.db --inspect-file=inspect-data.json  from the configuration directory - any database files listed here will be treated as immutable, so they should not be changed while Datasette is running 
                 
                 
                     templates/  - a directory containing  Custom templates 
                 
                 
                     plugins/  - a directory containing plugins, see  Writing one-off plugins 
                 
                 
                     static/  - a directory containing static files - these will be served from  /static/filename.txt , see  Serving static files","[""Settings""]",[]